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

ゝ一纸荒年。 2022-08-18 05:46 123阅读 0赞

使用面向切面编程统计流量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;  
    \}  
  
\}