使用面向切面编程统计流量aop

使用面向切面编程统计流量aop

package com.xxxxxx.dhm.common.uif.aop.intercaptor;

import java.util.List;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;

import com.xxxxxx.dhm.common.uif.aop.AopObserverManager;
import com.xxxxxx.dhm.common.uif.aop.AopObserver;
import com.xxxxxx.dhm.common.uif.api.UifConstants;
import com.xxxxxx.dhm.common.uif.vo.ReturnMessage;

/**
 * aop实现对指定接口进行拦截
 * @author
 *
 */
public class ServiceVisitAdvice implements MethodInterceptor
{

    private Logger logger = Logger.getLogger(ServiceVisitAdvice.class);

    private static List<AopObserver> bServerList = null;

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable
    {
        long procTime = System.currentTimeMillis();
        try
        {
            if (bServerList == null)
            {
                bServerList = AopObserverManager.addAopObserver();
            }
            ReturnMessage resultMsg = null;

            for (AopObserver aop : bServerList)
            {
                resultMsg = aop.informManager(invocation);
                if (!resultMsg.getReturnCode().equals(UifConstants.MESSAGE_SEND_SUCCESS))
                {
                    return resultMsg.getResponse();
                }
            }
            Object result = invocation.proceed();
            return result;
        }
        finally
        {
            procTime = System.currentTimeMillis() - procTime;
            if (logger.isInfoEnabled())
            {
                logger.info("execute " + invocation.getThis().getClass().getSimpleName() + " Time :" + procTime);
            }

        }

    }
}

package com.xxxxxx.dhm.common.uif.aop.obServerImpl.flux;

import java.util.HashMap;
import java.util.List;
import com.xxxxxx.dhm.common.config.impl.XMLFactory;

/**
 * 流量统计管理类
 * @author
 *
 */
public class FluxManager
{
    /**
     * 需要统计那些接口的流量
     */
    private static HashMap<String, InterfaceItem> interfaceMap = new HashMap<String, InterfaceItem>();

    /**
     * 是否需要统计,默认为需要统计
     */
    private static boolean isNeedStatic = true;

    /**
     * 初始化需要统计流量的接口
     */
    @SuppressWarnings("unchecked")
    public static void initVisitStaticConfig()
    {

        List list = XMLFactory.getValueList("statistics.interface.isStatistics");

        if (null != list && list.size() > 0)
        {
            for (int i = 0; i < list.size(); i++)
            {
                // 是否需要统计
                boolean isStatistics = XMLFactory.getValueBoolean("statistics.interface(" + i + ").isStatistics");
                if (isStatistics)
                {
                    String interfaceName = XMLFactory.getValueString("statistics.interface(" + i + ").interfaceName");
                    String interfaceZhName = XMLFactory.getValueString("statistics.interface(" + i
                            + ").interfaceZhName");
                    Long maxCount = XMLFactory.getValueLong("statistics.interface(" + i
                            + ").maxCount");
                    InterfaceItem ii = new InterfaceItem(interfaceName, interfaceZhName,maxCount);
                    interfaceMap.put(interfaceName, ii);
                }

            }
        }

    }

    public static boolean isNeedStatic()
    {
        return isNeedStatic;
    }

    public static void setNeedStatic(boolean isNeedStatic)
    {
        FluxManager.isNeedStatic = isNeedStatic;
    }

    public static HashMap<String, InterfaceItem> getInterfaceMap()
    {
        return interfaceMap;
    }

    public static void setInterfaceMap(HashMap<String, InterfaceItem> interfaceMap)
    {
        FluxManager.interfaceMap = interfaceMap;
    }

}


package com.xxxxxx.dhm.common.uif.aop.obServerImpl.flux;

import org.aopalliance.intercept.MethodInvocation;

import com.xxxxxx.dhm.common.uif.aop.AopObserver;
import com.xxxxxx.dhm.common.uif.aop.util.AopHelp;
import com.xxxxxx.dhm.common.uif.api.UifConstants;
import com.xxxxxx.dhm.common.uif.vo.ReturnMessage;

/**
 * 流量统计上报实现类
 * @author
 *
 */
public class FluxObServer implements AopObserver
{
    private ReturnMessage msg = new ReturnMessage(UifConstants.MESSAGE_SEND_SUCCESS);

    @SuppressWarnings("unchecked")
    @Override
    public ReturnMessage informManager(MethodInvocation invocation)
    {
        try
        {
            /**
             * 需要统计时才进行统计
             */
            if (FluxManager.isNeedStatic())
            {
                Class clazz = invocation.getThis().getClass();
                String className = clazz.getSimpleName();
                AopHelp.appearVistor(className);
            }

        }
        catch (Exception e)
        {

        }
        return msg;

    }
}

package com.xxxxxx.dhm.common.uif.aop.obServerImpl.flux;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class InterfaceItem
{
    /**
     * 接口名称
     */
    private String interfaceName;
    /**
     * 接口对应的接口中文名称
     */
    private String interfaceZhName;
    /**
     * 开始统计的时间点
     */
    private String beginTime;
    /**
     * 总访问数量
     */
    private Long count;
    /**
     * 结束时间
     */
    private String endTime;
    /**
     * 监听的IP地址
     */
    private String ip;

    /**
     * 允许的最大值
     */
    private Long maxCount;

    /**
     * 是否统计
     */
    private boolean isStatistics;

    public InterfaceItem(String interfaceName, String interfaceZhName, Long maxCount)
    {
        this.interfaceName = interfaceName;
        this.interfaceZhName = interfaceZhName;
        this.maxCount = maxCount;
        //默认都需要统计
        this.isStatistics = true;        
        this.ip = getHostIP();
    }

    public boolean isStatistics()
    {
        return isStatistics;
    }

    public void setStatistics(boolean isStatistics)
    {
        this.isStatistics = isStatistics;
    }

    /**
     * 查询hostIP
     * @return
     */
    private String getHostIP()
    {

        try
        {
            return InetAddress.getLocalHost().getHostAddress();
        }
        catch (UnknownHostException e)
        {

        }
        return null;
    }

    public String getInterfaceName()
    {
        return interfaceName;
    }

    public void setInterfaceName(String interfaceName)
    {
        this.interfaceName = interfaceName;
    }

    public String getInterfaceZhName()
    {
        return interfaceZhName;
    }

    public void setInterfaceZhName(String interfaceZhName)
    {
        this.interfaceZhName = interfaceZhName;
    }

    public String getBeginTime()
    {
        return beginTime;
    }

    public void setBeginTime(String beginTime)
    {
        this.beginTime = beginTime;
    }

    public Long getCount()
    {
        return count;
    }

    public void setCount(Long count)
    {
        this.count = count;
    }

    public String getEndTime()
    {
        return endTime;
    }

    public void setEndTime(String endTime)
    {
        this.endTime = endTime;
    }

    public void reset()
    {
        this.beginTime = null;
        this.count = 0L;
        this.endTime = null;

    }

    public Long getMaxCount()
    {
        return maxCount;
    }

    public void setMaxCount(Long maxCount)
    {
        this.maxCount = maxCount;
    }

    public String getIp()
    {
        return ip;
    }

    public void setIp(String ip)
    {
        this.ip = ip;
    }

}


package com.xxxxxx.dhm.common.uif.aop.util;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import com.xxxxxx.dhm.common.uif.aop.obServerImpl.flux.FluxManager;
import com.xxxxxx.dhm.common.uif.aop.obServerImpl.flux.InterfaceItem;
import com.xxxxxx.dhm.common.uif.config.Constants;

/**
 * aop拦截器帮助类
 * @author
 *
 */
public class AopHelp
{

    /***
     * 判断是否需要对此方法流量进行统计
     * @param methodName
     * @return
     */
    public static boolean isNeedStatistics(String methodName)
    {
        if (null == methodName)
        {
            return false;
        }
        HashMap<String, InterfaceItem> map = FluxManager.getInterfaceMap();
        if (!map.containsKey(methodName))
        {
            return false;
        }
        InterfaceItem inter = map.get(methodName);
        if (!inter.isStatistics())
        {
            return false;
        }
        return true;
    }

    /**
     * 流量统计工具类
     * @param methodName
     */
    public static void appearVistor(String methodName)
    {
        if (!isNeedStatistics(methodName))
        {
            return;
        }
        InterfaceItem interfaceItem = FluxManager.getInterfaceMap().get(methodName);

        Long count = interfaceItem.getCount();
        // 第一次统计或统计超过最大值,刚重置
        if (null == count || count > interfaceItem.getCount() || count >= Long.MAX_VALUE)
        {
            resetAppearVistor(methodName);
        }
        // 从未统计过或是已被初始化,设置开始统计的时间点
        if (null == interfaceItem.getBeginTime())
        {
            interfaceItem.setBeginTime(getSysDate(Constants.YYYYMMDDHHMMSS, new Date()));
        }
        count = interfaceItem.getCount();
        count++;
        interfaceItem.setCount(count);
        // 设置本次统计的结束时间
        interfaceItem.setEndTime(getSysDate(Constants.YYYYMMDDHHMMSS, new Date()));

    }

    /**
     * String methodName 不为空则只重置此接口的统计,methodName为空则重置所有接口
     * @param methodName
     */
    public static void resetAppearVistor(String methodName)
    {
        if (null == methodName || "".equals(methodName))
        {
            FluxManager.initVisitStaticConfig();
        }
        // 包含
        if (FluxManager.getInterfaceMap().containsKey(methodName))
        {
            InterfaceItem interfaceItem = FluxManager.getInterfaceMap().get(methodName);
            interfaceItem.reset();

        }

    }

    /**
     * @param formatStr
     *            日期格式字符串
     * @param date
     *            日期
     * @return String 日期的字符串型式
     */
    public static String getSysDate(String formatStr, Date date)
    {

        String dateStr = null;
        try
        {
            SimpleDateFormat sfTemp = new SimpleDateFormat(formatStr);
            dateStr = sfTemp.format(date);
            return dateStr;
        }
        catch (Exception e)
        {
        }
        return dateStr;

    }
}

package com.xxxxxx.dhm.common.uif.aop;

import org.aopalliance.intercept.MethodInvocation;

import com.xxxxxx.dhm.common.uif.vo.ReturnMessage;

public interface AopObserver
{
    ReturnMessage informManager(MethodInvocation invocation);
}

package com.xxxxxx.dhm.common.uif.aop;

import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import com.xxxxxx.dhm.common.config.impl.XMLFactory;
import com.xxxxxx.dhm.common.uif.jaxwsserver.JaxwsServer;

/**
 *
 * @author
 *
 */
public class AopObserverManager
{

    public static Logger logger = Logger.getLogger(JaxwsServer.class);

    @SuppressWarnings("unchecked")
    public static List<AopObserver> addAopObserver()
    {
        List<AopObserver> bServerList = new ArrayList<AopObserver>();

        List list = XMLFactory.getValueList("aopObserver.observer.observerName");

        if (null != list && list.size() > 0)
        {
            for (int i = 0; i < list.size(); i++)
            {

                String observerName = XMLFactory.getValueString("aopObserver.observer(" + i + ").observerName");

                try
                {
                    Class clazz = Class.forName(observerName.trim());
                    Object o = clazz.newInstance();
                    bServerList.add((AopObserver) o);
                }
                catch (Exception e)
                {
                    logger.error("AopObserverManager init is fail!:", e);
                }

            }
        }

        return bServerList;
    }

}