精华内容
下载资源
问答
  • 写了个拦截器,每调用一个接口,开启一个新的线程计数+1。因为计数与系统逻辑是分开的,所以...现在代码如下:publicclassModuleStatisticsInterceptorimplementsInterceptor{/***统计接口调用次数*/@Overridepubli...

    写了个拦截器,每调用一个接口,开启一个新的线程计数+1。因为计数与系统逻辑是分开的,所以放在另外一个线程里。

    但是这样是否会带来负载过高?有没有什么好的解决办法?按照key-value周期性的存储吗?

    现在代码如下:public class ModuleStatisticsInterceptor implements Interceptor {

    /**

    * 统计接口调用次数

    */

    @Override

    public void intercept(Invocation inv) {

    String controllerPath = inv.getControllerKey();

    APICallCount(controllerPath.substring(1, controllerPath.length()), inv.getMethodName());

    inv.invoke();

    }

    /**

    * 统计接口调用次数(另外的线程中执行)

    * @param className controller类名

    * @param methodName controller中的方法名

    */

    public static void APICallCount(String className, String methodName) {

    new Thread(new Runnable() {

    public void run() {

    try {

    Record record = Db.findFirst("SELECT controllerName FROM module_statistics WHERE controllerName = ? AND methodName = ?", className, methodName);

    if(record == null) {

    Db.update("INSERT INTO module_statistics(controllerName, methodName, count, state) values(?,?, 0, 1)", className, methodName);

    }

    Db.update("UPDATE module_statistics SET count = count + 1 WHERE controllerName = ? AND methodName = ? LIMIT 1", className, methodName);

    } catch (Exception ex) {

    LogKit.error("统计出错:" + className + "/" + methodName);

    }

    }

    }).start();

    }

    }

    展开全文
  • 1 viakiba 325 天前 Sleuth + Zipkin 2 ayonel 325 天前 这些是监控系统干的活,国内比较好的是 CAT,但是系统比较庞大。或者 metrics,比较轻量。... java 平台 spri...
      

        1

    viakiba   325 天前

    Sleuth + Zipkin

    ayonel 

        2

    ayonel   325 天前

    这些是监控系统干的活,国内比较好的是 CAT,但是系统比较庞大。或者 metrics,比较轻量。https://github.com/dropwizard/metrics

    msaionyc 

        3

    msaionyc   325 天前

    java 平台 spring aop 做这种事情很容易了吧

    hihipp 

        4

    hihipp   325 天前

    https://skywalking.apache.org/zh/

    lihongjie0209 

        5

    lihongjie0209   325 天前

    自己写一个拦截器不就好了

    w292614191 

        6

    w292614191   325 天前

    druid 可以监控以下内容:
    SQL 监控
    SQL 防火墙
    Web 应用
    URI 监控
    Session 监控
    Spring 监控
    JSON API

      

        7

    xiaoyaojc   325 天前

    如果只是这些需求,自己做个 aop 就得了,打个 log,自己统计下就完事了

    Varobjs 

        8

    Varobjs   325 天前 via Android

    日志做好,分析日志就可以吧

    whp1473 

        9

    whp1473   325 天前

    普罗米修斯

    aitaii 

        10

    aitaii   325 天前 via iPhone

    prometheus

    gz911122 

        11

    gz911122   325 天前

    普罗米修斯 + 1

    seanxx 

        12

    seanxx   325 天前

    aop + metric
    我们项目就在用

      

        13

    quadrapop   325 天前

    一般用日志就能实现,不过有框架的-_-

    yannanfei 

        14

    yannanfei   325 天前

    per4j 可以统计调用量,平均耗时等

      

        15

    Aresxue   325 天前

    简单点就 aop,还想要高性能和扩展性就用 JVMTI, 比如 Instrumentation (编码复杂度要高很多)

    luozic 

        16

    luozic   324 天前

    前面搞个 api gateway 啥都齐了,不要在一个里面搞太多东西。

    phantomzz 

        17

    phantomzz   324 天前 via Android

    Metrics:Prometheus actuator micrometer
    Tracing:jaeger zipkin pinpoint

    conn4575 

        18

    conn4575   324 天前 via Android

    java 的话就用 cat 吧,其他语言用 prometheus

    ohyeahhh 

        19

    ohyeahhh   324 天前

    谢谢各位,我搞了个拦截器,嘿嘿

      

        20

    jiaozongguan   321 天前 via Android

    apache 日志了解下

    展开全文
  •  很多时候会需要提供一些统计记录的,比如某个服务一个月的被调用量、接口的调用次数、成功调用次数等等。 优点:  使用AOP+Hendler对业务逻辑代码无侵入,完全解耦。通过spring boot自带的健康检查接口(/h...

    转载:https://www.cnblogs.com/yuwenhui/p/9809671.html

    SpringBoot(审计) 统计接口调用次数及成功率

    介绍:

      很多时候会需要提供一些统计记录的,比如某个服务一个月的被调用量、接口的调用次数、成功调用次数等等。

    优点:

      使用AOP+Hendler对业务逻辑代码无侵入,完全解耦。通过spring boot自带的健康检查接口(/health)方便、安全。

    注意:

      数据没有被持久化,只保存在内存中,重启后数据将被重置。可按需自己实现 

    代码:

      AOP:在AOP中调用Handler

     

    @Component
    @Aspect
    public class ControllerAdvice {
        private static ILogger log = LoggerFactory.getLogger(ControllerAdvice.class);
    
        @Around("execution(public * *..*controller.*.*(..))")
        public Object handle(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            Object result;
            try {
                Function<ProceedingJoinPoint, AbstractControllerHandler> build = AbstractControllerHandler.getBuild();
                if (null == build) {
                    AbstractControllerHandler.registerBuildFunction(DefaultControllerHandler::new);
                }
                build = AbstractControllerHandler.getBuild();
                AbstractControllerHandler controllerHandler = build.apply(proceedingJoinPoint);
                if (null == controllerHandler) {
                    log.warn(String.format("The method(%s) do not be handle by controller handler.", proceedingJoinPoint.getSignature().getName()));
                    result = proceedingJoinPoint.proceed();
                } else {
                    result = controllerHandler.handle();
                }
            } catch (Throwable throwable) {
                RuntimeHealthIndicator.failedRequestCount++;
                log.error(new Exception(throwable), "Unknown exception- -!");
    
                throw throwable;
            }
    
            return result;
        }
    }

     

     Handler:执行记录的逻辑

     抽象类:AbstractControllerHandler 

    public abstract class AbstractControllerHandler {
        private static ILogger log = LoggerFactory.getLogger(AbstractControllerHandler.class);
    
        private static Function<ProceedingJoinPoint, AbstractControllerHandler> build;
    
        public static Function<ProceedingJoinPoint, AbstractControllerHandler> getBuild() {
            return build;
        }
    
        public static void registerBuildFunction(Function<ProceedingJoinPoint, AbstractControllerHandler> build) {
            Assert.isNotNull(build, "build");
    
            AbstractControllerHandler.build = build;
        }
    
        protected ProceedingJoinPoint proceedingJoinPoint;
        protected HttpServletRequest httpServletRequest;
        protected String methodName;
        protected String uri;
        protected String requestBody;
        protected String ip;
        protected Method method;
        protected boolean inDataMasking;
        protected boolean outDataMasking;
    
    
        public AbstractControllerHandler(ProceedingJoinPoint proceedingJoinPoint) {
            Assert.isNotNull(proceedingJoinPoint, "proceedingJoinPoint");
    
            this.proceedingJoinPoint = proceedingJoinPoint;
            Signature signature = this.proceedingJoinPoint.getSignature();
            this.httpServletRequest = this.getHttpServletRequest(this.proceedingJoinPoint.getArgs());
            this.methodName = signature.getName();
            this.uri = null == this.httpServletRequest ? null : this.httpServletRequest.getRequestURI();
            this.requestBody = this.formatParameters(this.proceedingJoinPoint.getArgs());
            this.ip = null == this.httpServletRequest ? "" : CommonHelper.getIp(this.httpServletRequest);
            this.inDataMasking = false;
            this.outDataMasking = false;
            if (signature instanceof MethodSignature) {
                MethodSignature methodSignature = (MethodSignature) signature;
                try {
                    this.method = proceedingJoinPoint.getTarget().getClass().getMethod(this.methodName, methodSignature.getParameterTypes());
                    if (null != this.method) {
                        LogDataMasking dataMasking = this.method.getDeclaredAnnotation(LogDataMasking.class);
                        if (null != dataMasking) {
                            this.inDataMasking = dataMasking.in();
                            this.outDataMasking = dataMasking.out();
                        }
                    }
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public abstract Object handle() throws Throwable;
    
        protected void logIn() {
            String requestBody = this.requestBody;
            if (this.inDataMasking) {
                requestBody = "Data Masking";
            }
            log.info(String.format("Start-[%s][%s][%s][body: %s]", this.ip, this.uri, this.methodName, requestBody));
        }
    
        protected void logOut(long elapsedMilliseconds, boolean success, String responseBody) {
            if (success) {
                if (this.outDataMasking) {
                    responseBody = "Data Masking";
                }
                log.info(
                        String.format(
                                "Success(%s)-[%s][%s][%s][response body: %s]",
                                elapsedMilliseconds,
                                this.ip,
                                this.uri,
                                this.methodName,
                                responseBody));
            } else {
                log.warn(
                        String.format(
                                "Failed(%s)-[%s][%s][%s][request body: %s][response body: %s]",
                                elapsedMilliseconds,
                                this.ip,
                                this.uri,
                                this.methodName,
                                this.requestBody,
                                responseBody));
            }
        }
    
        protected HttpServletRequest getHttpServletRequest(Object[] parameters) {
            try {
                if (null != parameters) {
                    for (Object parameter : parameters) {
                        if (parameter instanceof HttpServletRequest) {
                            return (HttpServletRequest) parameter;
                        }
                    }
                }
    
                return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            } catch (Exception e) {
                log.error(e);
    
                return null;
            }
        }
    
        protected String formatParameters(Object[] parameters) {
            if (null == parameters) {
                return null;
            } else {
                StringBuilder stringBuilder = new StringBuilder();
                for (int i = 0; i < parameters.length; i++) {
                    Object parameter = parameters[i];
                    if (parameter instanceof HttpServletRequest || parameter instanceof HttpServletResponse) {
                        continue;
                    }
    
                    stringBuilder.append(String.format("[%s]: %s.", i, JSON.toJSONString(parameter)));
                }
    
                return stringBuilder.toString();
            }
        }

     

     实现类:

    public class DefaultControllerHandler extends AbstractControllerHandler {
        private static ILogger log = LoggerFactory.getLogger(DefaultControllerHandler.class);
        private static int currentMonth = Calendar.getInstance().get(Calendar.MONTH) + 1;
    
        public DefaultControllerHandler(ProceedingJoinPoint proceedingJoinPoint) {
            super(proceedingJoinPoint);
        }
    
        @Override
        public Object handle() throws Throwable {
            long timestamp = System.currentTimeMillis();
            this.logIn();
    
            ResponseDto responseDto;
            boolean success = false;
            try {
                Object result = proceedingJoinPoint.proceed();
                if (result instanceof ResponseDto) {
                    responseDto = (ResponseDto) result;
                } else {
                    responseDto = ResponseDto.success(result);
                }
                success = true;
                RuntimeHealthIndicator.successRequestCount++;
            } catch (BusinessException e) {
    //            RuntimeHealthIndicator.failedRequestCount++;
                if (this.isDebugLogLevel()) {
                    log.error(e);
                }
    
                responseDto = new ResponseDto<>(e.getCode(), e.getMessage(), null);
            } catch (Exception e) {
                RuntimeHealthIndicator.failedRequestCount++;
    
                if (this.isDebugLogLevel()) {
                    log.error(e);
                }
    
                responseDto = ResponseDto.failed(ExceptionDefinitions.ServerError, e.getMessage(), null);
            } finally {
                Calendar cale = Calendar.getInstance();
                if (currentMonth != (cale.get(Calendar.MONTH) + 1)) {
                    String recodeKey = String.format("%d年%d月",
                            cale.get(Calendar.YEAR), cale.get(Calendar.MONTH) + 1);
                    String recodeValue = "successCount:" + RuntimeHealthIndicator.successRequestCount +
                            " failedCount:" + RuntimeHealthIndicator.failedRequestCount;
                    RuntimeHealthIndicator.historyRequestRecode.put(recodeKey, recodeValue);
                    RuntimeHealthIndicator.successRequestCount = 0;
                    RuntimeHealthIndicator.failedRequestCount = 0;
                    currentMonth = cale.get(Calendar.MONTH);
                }
            }
    
            long duration = System.currentTimeMillis() - timestamp;
            RuntimeHealthIndicator.markRestApiInvoked(this.methodName, (int) duration);
            this.logOut(duration, success, JSON.toJSONString(responseDto));
    
            return responseDto;
        }
    
        public boolean isDebugLogLevel() {
            return log.isEnabled(LogLevel.DEBUG);
        }
    }

    Health接口

    @Component
    public class RuntimeHealthIndicator extends AbstractHealthIndicator {
        private static ILogger log = LoggerFactory.getLogger(ApplicationInstanceManager.class);
        private static Map<String, RestApiInvokeStatus> restApiInvokeStatuses = new HashMap<>();
        public static long failedRequestCount = 0;
        public static long successRequestCount = 0;
    
        public static Map<String, Object> historyRequestRecode;
        private Map<String, Object> details;
    
        public RuntimeHealthIndicator() {
            this.details = new HashMap<>();
            RuntimeHealthIndicator.historyRequestRecode = new HashMap<>();
    
            this.details.put("startTime", new Date(ManagementFactory.getRuntimeMXBean().getStartTime()));
            this.details.put("path", RuntimeHealthIndicator.class.getClassLoader().getResource("").getPath());
            this.details.put("osName", System.getProperty("os.name"));
            this.details.put("osVersion", System.getProperty("os.version"));
            this.details.put("javaVersion", System.getProperty("java.version"));
            try {
                this.details.put("ip", ZGHelper.getIpV4());
            } catch (SocketException e) {
                log.error(e, "Failed to get Ipv4.");
            }
        }
    
        @Override
        protected void doHealthCheck(Health.Builder builder) throws Exception {
    
            ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
            while (null != threadGroup.getParent()) {
                threadGroup = threadGroup.getParent();
            }
            this.details.put("threadCount", threadGroup.activeCount());
            OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
            this.details.put("cpuUsageRate", operatingSystemMXBean.getSystemCpuLoad());
            this.details.put(
                    "memoryUsageRate",
                    (float) (operatingSystemMXBean.getTotalPhysicalMemorySize() - operatingSystemMXBean.getFreePhysicalMemorySize()) / (float) operatingSystemMXBean.getTotalPhysicalMemorySize());
            this.details.put("failedRequestCount", RuntimeHealthIndicator.failedRequestCount);
            this.details.put("successRequestCount", RuntimeHealthIndicator.successRequestCount);
            this.details.put("restApiInvokeStatuses", RuntimeHealthIndicator.restApiInvokeStatuses);
            this.details.put("historyRequestRecode",RuntimeHealthIndicator.historyRequestRecode);
    
            for (Map.Entry<String, Object> detail : this.details.entrySet()) {
                builder.withDetail(detail.getKey(), detail.getValue());
            }
            builder.up();
        }
    
        public static void markRestApiInvoked(String name, int duration) {
            if (StringUtils.isBlank(name)) {
                return;
            }
    
            if (!RuntimeHealthIndicator.restApiInvokeStatuses.containsKey(name)) {
                RuntimeHealthIndicator.restApiInvokeStatuses.put(name, new RestApiInvokeStatus(name));
            }
    
            RestApiInvokeStatus restApiInvokeStatus = RuntimeHealthIndicator.restApiInvokeStatuses.get(name);
            restApiInvokeStatus.setDuration(duration);
        }
    }

     

     

    public class RestApiInvokeStatus {
        private String name;
        private Date startDate;
        private Date latestDate;
        private long times;
        private float averageDuration;
        private int minDuration;
        private int maxDuration;
        private int[] durations;
    
        public String getName() {
            return name;
        }
    
        public Date getStartDate() {
            return startDate;
        }
    
        public Date getLatestDate() {
            return latestDate;
        }
    
        public long getTimes() {
            return times;
        }
    
        public int getMinDuration() {
            return minDuration;
        }
    
    
        public int getMaxDuration() {
            return maxDuration;
        }
    
        public RestApiInvokeStatus(String name) {
            Assert.isNotBlank(name, "name");
    
            this.name = name;
            this.durations = new int[1000];
            this.minDuration = Integer.MAX_VALUE;
            this.maxDuration = Integer.MIN_VALUE;
            Date now = new Date();
            this.startDate = now;
            this.latestDate = now;
    
        }
    
        public void setDuration(int duration) {
            this.durations[(int) (this.times % this.durations.length)] = duration;
            this.maxDuration = this.maxDuration > duration ? this.maxDuration : duration;
            this.minDuration = this.minDuration < duration ? this.minDuration : duration;
            this.latestDate = new Date();
            this.times++;
        }
    
        public float getAverageDuration() {
            long length = this.times < this.durations.length ? this.times : this.durations.length;
    
            int count = 0;
            for (int i = 0; i < length; i++) {
                count += this.durations[i];
            }
            this.averageDuration = (float) count / (float) length;
    
            return this.averageDuration;
        }
    }

     

    展开全文
  • 关于统计API调用次数,一直都没有比较通用的方案,那么今天我来给一个解决方案,从应用层解决,不需要开发人员去做(即使去做也不一定比这个好,别觉得哥狂妄).好了也不屁话这么多,开正题了. 0x1 ngx_dynamic_...

    关于统计API调用次数,一直都没有比较通用的方案,那么今天我来给一个解决方案,从应用层解决,不需要开发人员去做(即使去做也不一定比这个好,别觉得哥狂妄).好了也不屁话这么多,开正题了.

    0x1

    ngx_dynamic_limit_req_module还是需要这个模块

    cd redis-4.0**version**/deps/hiredis
    make 
    make install 
    
    
    git clone https://github.com/limithit/ngx_dynamic_limit_req_module.git
    cd ngx_dynamic_limit_req_module
    git checkout limithit-API_alerts
    ./configure --add-module=/path/to/this/ngx_dynamic_limit_req_module 
    make
    make install
    
    
    配置参考:
    worker_processes  2;
    events {
        worker_connections  1024;
    }
    http {
        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  65;
        
        dynamic_limit_req_zone $binary_remote_addr zone=one:10m rate=100r/s redis=127.0.0.1 block_second=300;
        
        server {
            listen       80;
            server_name  localhost;
            location / {
                if ($document_uri ~* "index.html"){
                 dynamic_limit_req zone=one burst=100 nodelay;
                dynamic_limit_req_status 403;
                     }
    				 if ($document_uri ~* "about.html"){
                    dynamic_limit_req zone=one burst=30 nodelay mail_to=123@qq.com api_max=20;  #mail_to是要通知邮箱 api_max是当请求达到20次以上就发邮件通知5分钟内只发一次
                    dynamic_limit_req_status 405;
                     }
                root   html;
                index  index.html index.htm;
               
            }
            error_page   403 500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }
        }
    
    }

    其实邮箱是选填的,不需要通知的话就不用填,如果需要全局记录的话,不需要加筛选条件document_uri 

     server {
            listen       80;
            server_name  localhost;
            location / {
                dynamic_limit_req zone=one burst=100 nodelay;
                dynamic_limit_req_status 403;
                     
    				
                root   html;
                index  index.html index.htm;
               
            }
            error_page   403 500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }
        }

    0x2

    会按天记录每天PV,UV,AllCount是每个域名的全部请求以及每个页面的请求次数,这取决于你的筛选条件

     

    0x3

    大概有人会问redis能存多少个key呢又会占用多少内存呢,根据官方的描述是100万个key 大概85MB的内存

    Redis最多可以处理2 ^32键,并且在实践中经过测试,每个实例至少处理2.5亿个键。

    每个哈希,列表,集和排序集可以容纳2 ^32个元素。

    换句话说,您的限制可能是系统中的可用内存。

    所以不必但心数据日渐增多的困扰

     

    转载于:https://my.oschina.net/MasterXimen/blog/2996579

    展开全文
  • Mockito 验证方法调用次数

    千次阅读 2019-08-15 19:36:45
    – Start ...import java.util.List; import org.junit.jupiter.api.Test; import org.mockito.Mockito; @SuppressWarnings("unchecked") class VerifyMethodCalledTest { @Test void test() { ...
  • JMock实践---(六)方法调用次数

    千次阅读 2017-07-30 23:21:40
    声明: Author:赵志乾 Date:2017-7-30 Declaration:All Right Reserved!!! ...1、测试通常需要指定预期某些方法允许出现被调用的次数。... 调用次数定义了预期方法允许被调用次
  • 统计客户调用接口的次数

    万次阅读 2018-01-29 10:49:19
    由于用户行为异常,需要定位是哪个用户频繁调用某一个接口。日志大致格式如下:10:33:13.412 [DubboServerHandler-10.999.111.888:20880-thread-200] INFO c.s.f.c.a.ServiceExceptionAdvice[64] - call method ...
  • 题目描述: ...请你改写该程序,计算第n项的同时,统计调用了多少次函数fib(包括main()对fib()的调用)。 #include<stdio.h> int fib(int k); int main(void ) { int n; scanf("%d", &n); p...
  • 统计函数调用次数:import java.lang.Thread;public class CalculateCallTime implements Runnable { private static int times = 0; private static Object mem = new Object(); /** * 方法1: */ publi
  • Java调用Google Analytics API实现网站统计

    万次阅读 热门讨论 2011-11-10 23:19:36
    首先,申请Google帐号和Google Analytics服务,并将统计代码放入你想统计的网站中一段时间,确保你的Google Analytics中已有数据。  在Google Analytics中,进入你的配置文件修改界面,如图,记下红色标记的数字,...
  • 测试类:可以使用流加载文本文件,拼成String调用上边的方法进行统计,具体需要怎么使用自己研究 public class Counts { /** * @param args */ public static void main(String[] args) { // TODO Auto-...
  • java统计字符串中每个字符出现的次数

    万次阅读 多人点赞 2017-07-24 21:25:45
    统计该字符串中每个字符出现的次数,输出: a====5 b====3 c====1 d====1 e====1 f====1 g====1 h====1方法一: 采用HashMappublic static void count(String str){ //将字符串转化为字符数组
  • 一般第三方api都会有每分钟或者每秒限定调用次数的功能,这也是为了防止恶意调用攻击服务器而做的。开发中登陆次数,调用次数这些类似的功能都可以放到redis中去实现。 思路:前端发送接口调用请求,将可以作为唯一...
  • 测试页面: test.html test <!-- --> this is a test page. document.write("");...统计程序: pv.jsp    假设部署位置为http://127.0.0.1:
  • 通过REDIS实现限制API调用次数

    千次阅读 2020-07-06 06:52:07
    在对外提供api接口时,往往需要对api接口进行限制,某些情况下还需要做好防止接口被刷的功能。利用redis的自增计数特性可以很轻易的实现该功能。 关于Spring boot等项目集成redis就不再多说,这里... # api调用次数
  • 统计字符串数组中每个字符串所出现的次数 public class StringSameCount { private HashMap map; private int counter; public StringSameCount() { map = new HashMap(); } public void hashInsert(String ...
  • /输出出现单词次数的程序/ import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Scanner; import java.util.Set; public class Maptext1 { ...
  • java list统计某个元素出现的次数

    万次阅读 2017-09-29 17:44:06
    int count = ...java提供了方法,但实现原理是for循环,所以在大数据量下不建议使用,或者你要判断某个key出现的次数是不是大于某个标准值,则先对list排序,然后分批次list进行调用方法,满足就退出循环。
  • 统计一个字符串中各个字符出现的次数 import java.util.Iterator; import java.util.Set; import java.util.TreeMap; public class TreeMapDemo { //统计一个字符串中相应字符出现的次数 public static void ...
  • 如果一个手机号一天发送超过3次就提示不能发送: 二:前台的注册页面的代码:reg.jsp <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@taglib prefix="s" uri="/struts-tags"%> ...
  • 思路:遍历字符串,每遍历一次就做一次判断,如果符合条件,count++; Test{ public void main (String arg[]){ ...//调用getCount方法传入值 System.out.println(getCount(a,b)); } //构造getCount 方法 stat...
  • 调用MapReduce对文件中各个单词出现次数进行统计

    千次阅读 热门讨论 2020-12-06 18:02:12
    调用MapReduce对文件中各个单词出现次数进行统计 实验配置:系统:Ubuntu Kylin | 环境:Hapdoop | 软件:Eclipse 文章目录一、安装Linux二、准备工作1.创建Hadoop账户2.设置hadoop密码 :3.为hadoop用户增加管理员...
  • 基于Ubuntu在Hadoop的环境下调用MapReduce对文件中各个单词出现次数进行统计 目录一、安装配置操作系统二、安装Hadoop(伪分布模式)二、二、调用MapReduce执行WordCount对单词进行计数 一、安装配置操作系统   ...
  • java统计个数

    2011-10-22 14:26:11
    从一片文档中提取出所有的单词(word),然后计算每个单词出现的频率(次数),按照一定的次序将排序好的单词以“word(频率)”的形式打印出来
  • redis实现API接口调用调用次数的限制   参考地址:https://bbs.csdn.net/topics/391856106?page=1 参考地址:https://www.cnblogs.com/exceptioneye/p/4783904.html 参考地址:...
  • # 执行代码后算出来总是多3 ``` package work2; public class Part implements Runnable{ private int n = 800; private int i = 1; @Override public void run() { // TODO Auto-generated ...```
  • JDK是在一直在迭代更新的,很多我们熟悉的类也悄悄的添加了一些新的方法特性。...今天给大家讲一下HashMap在JDK8中添加的两个新方法compute和merge,从而实现一行代码实现单词统计的功能。一起来看看吧。
  • Java统计代码段的执行时间

    千次阅读 2018-05-03 15:28:40
    通常在进行代码测试和代码优化的时候,会想要知道代码执行时每段代码的执行时间,以便进行...统计字段有代码段、总时间(纳秒)、执行次数、平均时间。封装类:/** * 统计代码段执行时间。 * 在需要进行统计的代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,779
精华内容 29,911
关键字:

java统计方法调用次数

java 订阅