精华内容
下载资源
问答
  • import java.io.InputStream; import java.net.HttpURLConnection; import java.net.URL; import java.net.URLConnection; import java.sql.Connection; import java.sql.DriverManager; import java.sq...

    实际检测代码

    import java.io.InputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.net.URLConnection;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    public class InterfaceTest
    {
        public static void main(String[] args) throws Exception
        {
            //需导入Oracle驱动
            Class.forName("oracle.jdbc.OracleDriver");
            Connection conn = DriverManager.getConnection(
                    "jdbc:oracle:thin:@10.18.20.180:1521:MUDATA",
                    "MD_REF",
                    "MD_REF_2018");
            PreparedStatement statement = conn.prepareStatement("SELECT IATA_CD FROM T13_REF_AIRPORT_HUB");
            ResultSet resultSet = statement.executeQuery();
            List<String> data_list = new ArrayList<>();
            while (resultSet.next())
            {
                data_list.add("http://10.18.20.5:8082/mudata/api/v1/timechange/gettimezone/11/?changeType=3&airportCode=" + resultSet.getString(1) + "&dateTime=2019-09-11%2009:00:00");
    //            data_list.add("http://localhost:8080");//4s
            }
            String start_time=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date());
    //        int i=0;
            for (String data : data_list)
            {
    //            System.out.println(++i);
                new URL(data).openConnection().getInputStream();//调用一次
            }
            System.out.println(start_time);
            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
            statement.close();
            conn.close();
            //2019-10-12 11:12:49 844 2019-10-12 11:14:44 365
            //2019-10-12 11:19:42 559 2019-10-12 11:21:39 207
    
    
    
    
    //        String x="http://10.18.20.5:8082/mudata/api/v1/timechange/gettimezone/11/?changeType=3&airportCode=PVG&dateTime=2019-09-11%2009:00:00";
    //        HttpURLConnection http = (HttpURLConnection) new URL(x).openConnection();
    //        http.setRequestMethod("GET");
    
    //        URL u=new URL("http://10.68.169.204:8080/");
            //获取连接对象
    //        HttpURLConnection conn=(HttpURLConnection) u.openConnection();
    //        //连接
    //        conn.connect();
    //        //获取输入流
    //        InputStream in=conn.getInputStream();
    //        //读取输入流
    //        int r;
    //        byte[] bs=new byte[1024];
    //        StringBuffer sb=new StringBuffer();
    //        while((r=in.read(bs))!=-1) {
    //            sb.append(new String(bs, 0, r));
    //        }
    //        in.close();
    //        System.out.println(sb.toString());
    
    //        new URL("http://localhost:8080").openConnection().getInputStream();
        }
    }
    
    展开全文
  • 看代码: @Aspect @Component public class TimeCostAspect { private static Logger logger = LoggerFactory.getLogger(TimeCostAspect.class);... private static final String POINT = "execution (...

    看代码:

    @Aspect
    @Component
    public class TimeCostAspect {
        private static Logger logger = LoggerFactory.getLogger(TimeCostAspect.class);
        private static final String POINT = "execution (* com.ming..*.controller..*.*(..))";
    
        @Pointcut(POINT)
        public void performance() {
        }
    
        @Around("performance()")
        public Object watchPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
            Object obj = null;
            Object[] args = joinPoint.getArgs();
            long startTime = System.currentTimeMillis();
            obj = joinPoint.proceed(args);
            if (!(obj instanceof BaseVO)) {
                return obj;
            }
            long endTime = System.currentTimeMillis();
            BaseVO baseVO = (BaseVO) obj;
            baseVO.setCost(endTime - startTime);
            return baseVO;
        }
    }

     

    转载于:https://www.cnblogs.com/huzi007/p/8962545.html

    展开全文
  • 接口耗时优化与cpu飙高解决

    千次阅读 2021-06-12 16:41:16
    于是对各个接口耗时进行了分析, 将耗时top5的接口全部梳理出来。 让接口人自己对接口优化, 但是一般由于排期资源等,可能一时半会没有资源。 与接口人确认接口数据的实效性,确定接口是否可以加缓存以及缓存时间...

    最近突然接到上游业务侧通知,其中一个核心接口rt升高,最高耗时达到了15s左右,上游业务受到影响,于是开启了接口优化之路。

    优化思路

    梳理接口逻辑并加缓存

    梳理代码发现该接口依赖了很多其他接口数据。于是对各个接口耗时进行了分析, 将耗时top5的接口全部梳理出来。

    • 让接口人自己对接口优化, 但是一般由于排期资源等,可能一时半会没有资源。
    • 与接口人确认接口数据的实效性,确定接口是否可以加缓存以及缓存时间对数据影响。于是对接口中人员组织的信息等变化频率不高的接口加缓存, 如果缓存中取不到数据在调接口或者从数据库中取。
    • 改单个调用为批量调用。

    多线程

    通过分析,发现接口耗时的另一个原因是逻辑中有一个比较复杂逻辑计算,并且for的结果互相不影响,没有依赖,以此考虑使用多线程代替for循环。

    本例采用了线程池, 在spring初始化时候构建线程

    @Configuration
    public class ThreadPoolConfig {
       
        /**
         * 线程池维护线程所允许的空闲时间
         */
        @Value("${async.executor.thread.keep_alive_seconds}")
        private int keepAliveSeconds;
        /**
         * 线程池对拒绝任务(无线程可用)的处理策略
         */
        private ThreadPoolExecutor.CallerRunsPolicy callerRunsPolicy = new ThreadPoolExecutor.CallerRunsPolicy();
    
        private static final String EXECUTOR_THREAD = "AsyncExecutorThread-";
    
        @Bean(name = "ruleRunningExecutor")
        public ThreadPoolTaskExecutor ruleRunningExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(4);                //核心线程数4
            executor.setMaxPoolSize(4);                 //最大线程数4
            executor.setQueueCapacity(100);   //队列最大长度100
            executor.setKeepAliveSeconds(300);  //线程池维护线程所允许的空闲时间300s
            executor.setRejectedExecutionHandler(callerRunsPolicy); //线程池对拒绝任务(无线程可用)的处理策略
            executor.setThreadNamePrefix(EXECUTOR_THREAD); // 线程名字
            executor.setRejectedExecutionHandler(callerRunsPolicy); //拒绝策略
            executor.initialize();
            return executor;
        }
    }
    

    上面的@Config和@Bean用法请参考博文 Spring注解@Config与@Bean

    由于需要获取线程池返回结果,使用了CompletableFuture

    未使用自定义线程池版本

    // supplyAsync需要有返回值,runAsync不需要有返回值
    List<CompletableFuture<String>> futures = list.stream().map(a -> CompletableFuture.supplyAsync(() -> {
                try {
                        // 操作代码.....
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return a;
            })).collect(Collectors.toList());
    
    List<String> results = futures.parallelStream().map(CompletableFuture::join).filter(Objects::nonNull).collect(Collectors.toList());
    

    未自定义线程池时默认线程池根据服务器内核数创建线程数量。

    使用自定义线程池

     @Autowired
     @Qualifier(value = "ruleRunningExecutor")
     private Executor threadPoolExecutor;
    
            HashBasedTable<String, String, Object> preRuleResult = HashBasedTable.create();
    // supplyAsync需要有返回值,runAsync不需要有返回值
            List<CompletableFuture<HashBasedTable<String, String, Object>>> futures =
                    costItemFeeMap.stream().map(entry -> CompletableFuture.supplyAsync(() -> {
                        try {
                            return executeRuleEngine(ruleRequest, ruleData, bizKey, entry);
                        } catch (IOException e) {
                            throw new RuleEngineException(e);
                        }
                    }, threadPoolExecutor)).collect(Collectors.toList());
    
            futures.parallelStream().map(CompletableFuture::join).filter(Objects::nonNull).forEach(t -> {
                preRuleResult.putAll(t);
    
    1. 线程数量的计算公式:
    T(线程数) = N(服务器内核数) * u(期望cpu利用率) * (1 + E(等待时间)/C(计算时间));
    
    1. 获取服务器内核数:
    int count = Runtime.getRuntime().availableProcessors();
    
    1. 重点:
      此处join方法和CompletableFuture的get()方法类似,都是阻塞线程,等待结果,但是join方法不抛异常,不需要处理异常,让你代码更方便,get方法抛异常。

    CompletableFuture自定义线程池与Executors的运行效果差别不大,但CompletableFuture有很多组合式的异步编程方法:

    • runAsync:异步执行没有返回值;
    • supplyAsync:异步执行有返回值;
    • thenApply:继续执行当前线程future完成的函数,不需要阻塞等待其处理完成;
    • thenApplyAsync:在不同线程池异步地应用参数中的函数;
    • thenCompose:用于多个彼此依赖的futrue进行串联起来
    • thenCombine:并联起两个独立的future,注意,这些future都是在长时间计算都完成以后

    整体性能优化结果

    相同的数据量,耗时从15s左右优化到4s不到。

    本以为一切到此结束,但是没过多久测试小姐姐找上门来了,接口的cpu飙高,性能压测上不去,需要继续优化

    现象

    采购规则接口,压到* QPS左右cpu的利用率直接到%360+
    在这里插入图片描述
    问题定位

    1. 定位进程
      登陆机器,执行top命令, 查看CPU使用率
      top
      通过执行top命令,我看到,进程ID为3513的Java进程的CPU占用率达到了400%,基本可以定位到是我们的Java应用导致整个服务器的CPU占用率飙升
      定位线程
    • 使用top -Hp 3513

    找到对应的java线程 3562

    • 执行 获取十六进制
    printf "%x\n" 3562
    
    1. 利用jstack查询堆栈信息
      jstack -F 3513 | grep dea -A 100
      堆栈
    # cat jump.log  | grep 12f4 -A 100
    
    "AsyncExecutorThread-1" #218 prio=5 os_prio=0 tid=0x00007fe360901000 nid=0x12f4 runnable [0x00007fe321161000]
       java.lang.Thread.State: RUNNABLE
            at java.lang.Throwable.getStackTraceElement(Native Method)
            at java.lang.Throwable.getOurStackTrace(Throwable.java:827)
            - locked <0x00000006e100b288> (a java.lang.Throwable)
            at java.lang.Throwable.getStackTrace(Throwable.java:816)
            at ch.qos.logback.classic.spi.CallerData.extract(CallerData.java:60)
            at ch.qos.logback.classic.spi.LoggingEvent.getCallerData(LoggingEvent.java:258)
            at ch.qos.logback.classic.pattern.MethodOfCallerConverter.convert(MethodOfCallerConverter.java:22)
            at ch.qos.logback.classic.pattern.MethodOfCallerConverter.convert(MethodOfCallerConverter.java:19)
            at ch.qos.logback.core.pattern.FormattingConverter.write(FormattingConverter.java:36)
            at ch.qos.logback.core.pattern.PatternLayoutBase.writeLoopOnConverters(PatternLayoutBase.java:115)
            at ch.qos.logback.classic.PatternLayout.doLayout(PatternLayout.java:141)
            at ch.qos.logback.classic.PatternLayout.doLayout(PatternLayout.java:39)
            at ch.qos.logback.core.encoder.LayoutWrappingEncoder.encode(LayoutWrappingEncoder.java:115)
            at ch.qos.logback.core.OutputStreamAppender.subAppend(OutputStreamAppender.java:230)
            at ch.qos.logback.core.OutputStreamAppender.append(OutputStreamAppender.java:102)
            at ch.qos.logback.core.UnsynchronizedAppenderBase.doAppend(UnsynchronizedAppenderBase.java:84)
            at ch.qos.logback.core.spi.AppenderAttachableImpl.appendLoopOnAppenders(AppenderAttachableImpl.java:51)
            at ch.qos.logback.classic.Logger.appendLoopOnAppenders(Logger.java:270)
            at ch.qos.logback.classic.Logger.callAppenders(Logger.java:257)
            at ch.qos.logback.classic.Logger.buildLoggingEventAndAppend(Logger.java:421)
            at ch.qos.logback.classic.Logger.filterAndLog_1(Logger.java:398)
            at ch.qos.logback.classic.Logger.info(Logger.java:583)
            at com.bytedance.wfcrule.aop.ExecuteAspect.around(ExecuteAspect.java:19)
            at sun.reflect.GeneratedMethodAccessor115.invoke(Unknown Source)
            at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
            at java.lang.reflect.Method.invoke(Method.java:498)
            at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:644)
            at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:633)
            at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:70)
            at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
            at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:93)
            at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
            at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:688)
            at com.bytedance.wfcrule.rulefunction.BudgetItemCodeRiskRating$$EnhancerBySpringCGLIB$$191f5aa1.execute(<generated>)
            at com.bytedance.ruleengine.core.value.Variable.calculate(Variable.java:83)
            at com.bytedance.ruleengine.core.value.Variable.getValue(Variable.java:60)
            at com.bytedance.ruleengine.core.condition.NormalCondition.evaluate(NormalCondition.java:94)
            at com.bytedance.ruleengine.core.condition.ConditionGroup.evaluate(ConditionGroup.java:68)
            at com.bytedance.ruleengine.core.condition.ConditionSet.evaluate(ConditionSet.java:64)
            at com.bytedance.ruleengine.core.rule.Rule.execute(Rule.java:86)
            at com.bytedance.ruleengine.core.rule.NormalRuleSet.executeNormalRules(NormalRuleSet.java:212)
            at com.bytedance.ruleengine.core.rule.NormalRuleSet.doExecute(NormalRuleSet.java:137)
            at com.bytedance.ruleengine.core.rule.RuleSet.execute(RuleSet.java:172)
            at com.bytedance.ruleengine.core.BaseRuleEngine.execute(BaseRuleEngine.java:38)
            at com.bytedance.wfcrule.service.ruleengine.impl.BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl.getResult(BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl.java:418)
            at com.bytedance.wfcrule.service.ruleengine.impl.ApprovalAmountRuleOptionEngineExecuteServiceImpl.getResult(ApprovalAmountRuleOptionEngineExecuteServiceImpl.java:41)
            at com.bytedance.wfcrule.service.ruleengine.impl.BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl.executeRuleEngine(BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl.java:339)
            at com.bytedance.wfcrule.service.ruleengine.impl.BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl.lambda$null$3(BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl.java:314)
            at com.bytedance.wfcrule.service.ruleengine.impl.BudgetItemCodeApprovalAmountRuleEngineExecuteServiceImpl$$Lambda$1110/263997716.get(Unknown Source)
            at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1590)
            at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
            at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
            at java.lang.Thread.run(Thread.java:748)
    

    分析

    这个堆栈信息对定位到执行的二方包方法。 于是开始梳理代码,本地debug是否存在死循环等。

    排除法

    1. 是否线程过多导致
      操作:将原来核心线程数从4修改为2;
      现象:cpu性能没有明显变化,rt耗时增加
      结论:与线程数无关
    2. 排除是否本次多线程一起的cpu彪高
      现象:将原来代码部署,压测参数2qps, 600s, 执行, 现象复现。
      结论:说明与非本次多线程引起。
    3. 是否 json过大,解析导致
      现象:本地构造了一个json参数,并返回空, 压测参数2qps, 600s, cpu从1%左右,飙高到8%。
      结论:如果临时变量较大,并且多次新建临时变量将会导致ygc,引起cpu高。
    4. 频繁的Young GC导致CPU高。
      在这里插入图片描述
      现象: YGC达到了313次,非常频繁。
      结论:可能与大的临时变量相关,并调整jvm参数(与sre确认在pre环境调参)
      梳理代码:对临时变量,如大的map和list清理。

    优化后

    压测参数: *QPS,1200s

    • cpu负载降低,从原来92%+ 降低到44%;

    • rt平均响应时间从10.7s降低到1.4s
      在这里插入图片描述

    • cpu us降低,从原来的67%,降低到19.2%
      在这里插入图片描述

    展开全文
  • 在开发过程中,经常会遇到接口相应慢的情况,这个时候,就需要分析接口到底慢在哪里,需要清楚具体哪个查询慢了,然后再具体有针对性的优化。使用spirngframework 框架的工具类StopWatch ,还可以使org.apache....

           在开发过程中,经常会遇到接口相应慢的情况,这个时候,就需要分析接口到底慢在哪里,需要清楚具体哪个查询慢了,然后再具体有针对性的优化。使用spirngframework 框架的工具类StopWatch ,还可以使org.apache.commons.lang3.time.StopWatch
    ,个人常用的是使用spirngframework 的,比较方便。

       
    一,原来耗时统计都这样写:

     @Test
        public void testTime() throws InterruptedException {
            long startTime = System.currentTimeMillis();
            Thread.sleep(10000);
            long endTime = System.currentTimeMillis();
    
            logger.info("消耗时长是:{}", (endTime - startTime)/1000);
            // 消耗时长是:10
        }

    使用stopWatch之后,就方便多了

    @Test
        public void testStopWatch() throws InterruptedException {
            StopWatch stopWatch = new StopWatch("testStopWatch()方法");
            stopWatch.start("first task");
            Thread.sleep(100);
            stopWatch.stop();
    
            stopWatch.start("second task");
            Thread.sleep(200);
            stopWatch.stop();
    
            stopWatch.start("third task");
            Thread.sleep(400);
            stopWatch.stop();
    
            logger.info("耗时统计:{}", stopWatch.prettyPrint());
    
        }

    使用方法:

    就是new 一个stopWatch 实例(默认名称为“”),可添加上名称,调用该实例的start 和stop 方法
    可以获得耗时统计,消耗时间(毫米),百分比,每个任务的名称,可以很直观的看到每段代码的
    运行时间,更加方便的查询
        
    耗时统计:StopWatch 'testStopWatch()方法': running time (millis) = 707
    -----------------------------------------
    ms     %     Task name
    -----------------------------------------
    00103  015%  first task
    00203  029%  second task
    00401  057%  third task

    二,参考文章

     https://www.dazhuanlan.com/2019/10/05/5d985bed4c1aa/

     

    展开全文
  • java 查看接口运行时各方法耗时

    千次阅读 2020-01-08 15:41:49
    使用开源工具: xrebel ...-javaagent:D:\XRebel-3.4.9\xrebel\xrebel.jar 注意,不要放在Program Files下。。因为中间有空格,会被认为是两个参数。导致如下的报错: agent library failed to init:...
  • Java接口回调一般用法

    2020-12-22 15:58:49
    Java接口回调一般用法:实现接口实际上和继承抽象类类似,只不过继承是在类的层面上操作,接口是在方法和常量集合的层面上操作,接口比抽象类更抽象、更简洁。可以把实现接口看成继承特定的一个或多个方法以及一些...
  • Java模拟耗时任务异步执行

    千次阅读 2017-11-07 20:15:58
    说明:耗时任务开启...1、回调接口定义 public interface ResponseCallBack { public void printMsg(String msg); } 2、模拟耗时任务线程 public class TestMain { public static void main(String[] args)
  • AOP实现接口耗时监控

    2020-05-15 10:17:47
    // service层的统计日志/耗时(方法所在的包) public static final String POINT = "execution (* cn.xy.os.contrlller.*.*(..))"; @Autowired InterfaceSlowService interfaceSlowService; @Pointcut(".
  • arthas分析接口耗时

    千次阅读 2020-09-16 11:08:12
    ... java -jar arthas-boot.jar 3 选择检测线程,回车 4 监听具体方法 trace <类的包全名> <检测方法> example: trace com.xueqiu.service.xqtong.Surve...
  • php 调用java 接口

    千次阅读 2018-03-31 20:55:56
    //请求 Java 接口 $url = "http://192.168.1.105:8081/credit/udun/udunInfo.do"; $post_data = array ("ydOrderId" =&gt; $data['ydOrderId']); $ch = curl_init(); curl_setopt($ch, ...
  • Java接口回调

    千次阅读 2020-01-03 13:48:30
    Java中接口回调机制 java接口回调机制想必大家并不陌生,其思想简单,应用广泛,如网络请求、界面的点击监听等,是一个java开发者必须要掌握的基本思想之一。 我们在做java开发时经常会遇到文件下载、请求服务器...
  • springMVC Aspect AOP 接口耗时统计

    千次阅读 2017-03-29 10:55:37
    在接口开发中,我们通常需要统计接口耗时,为后续接口性能做统计。在springMVC中可以用它的aop来记录日志。  1、在spring配置文件中开启AOP *************** 支持aop **************** --> aop:aspectj-...
  • linux上查看java耗时的线程命令

    千次阅读 2017-03-24 20:42:15
    2、top -Hp [pid] 或者 ps -mp [pid] -o THREAD, tid, time 查看最耗时的 TID即线程id prinrf "%x\n" [tid] 转成16进制 3、查看java中的线程类相关信息 jstack [pid] | grep [t...
  • 工作中用到的好用的接口耗时原因定位的工具Arthas,今天就写到博客中持久化下来吧。 官方文档(较全面):https://arthas.aliyun.com/doc/http-api.html#id6 适用场景:监控明显显示接口耗时较多,但是又无法直接定位...
  • Java接口幂等性多种解决方案

    千次阅读 2020-11-25 11:34:36
    Java接口幂等性的解决方案: java语音中,同一个接口相同的参数多次和一次请求产生的效果是一样,这样的过程即被称为满足幂等性 //这中情况无论执行多少次,结果都不受影响,是幂等的。 update user set age = ...
  • 接口耗时打印并统计

    千次阅读 2017-12-28 11:48:00
    1.可以利用Tomcat的access-log日志,让其打印出http请求的每次耗时。可以在 config/server.xml里Host标签下配置tomcat访问日志格式 &lt;Valve className="org.apache.catalina.valves.AccessLogValve&...
  • JAVA方法耗时信息捕捉并日志

    千次阅读 2015-11-24 17:16:59
    一. 设计思想:  1、要保证日志的先后顺序,要保证输出的先后... 2、其次就是要保证不要出现存储耗时时间的List量太大的情况,所以解决方法是  A、使用ThreadLocal,每个线程输出自己的日志,这样比较清晰;  
  • Java接口异步调用

    千次阅读 2017-10-12 07:49:47
    java接口调用从调用方式上可以分为3类:同步调用,异步调用,回调;同步调用基本不用说了,它是一种阻塞式的调用,就是A方法中直接调用方法B,从上往下依次执行。今天来说说异步调用。 什么是异步调用? 我的理解...
  • 对qps以及接口的平均耗时进行统计 特点 轻量: 共219KB(代码量约300行), 无需安装,加压即可使用 低侵入: 基于日志文件进行统计,无需修改原程序 使用说明 ...
  • 经过一天的开发调试终于搞懂了接口调用耗时并保存到数据库,并且保存到另外一个数据库,相当于双数据源 本功能共两个文件,一个java文件和一个数据库配置文件(HuTool jdbc读取数据库配置,相当轻量级的) 直接上...
  • /** * 拦截器,统计接口耗时 * * @author chqiuu */ @Slf4j public class TimeConsumingInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, ...
  • 做了一个接口,查询mongdb的,然后根据日志分析发现有个别请求非常慢,甚至主键查询都要几分钟了,通过生产实测,了解 到当时其实据库压力并不大,而且相同的条件直接用sql跑还是1秒左右返回的,就是在用接口调用的...
  • 统计接口平均耗时

    千次阅读 2020-07-17 11:22:39
    先看下结论,然后再说背景吧~~ 目录 结论 背景 命令分析 ...cat /home/homework/clog/webservice/access.log | grep '接口' | wc -l ...统计单个接口平均耗时 cat /home/homework/clog/webserver/access.log
  • N个例子让你彻底理解java接口回调

    千次阅读 多人点赞 2017-03-23 00:17:20
    说到接口回调,对于初学者来说,理解是真的难啊,不过没有关系,看完本篇文章,你马上就能理解接口回调啦!概念什么是接口回调?用我的理解,就是:A让B去做一件耗时的操作,而且并不知道要花费多少时间,B做完了后...
  • 服务端JAVA接口特别慢

    千次阅读 2018-07-04 17:27:52
    有些接口访问数据库,由腾讯到阿里,数据传输时间过长,然而一个接口常常不止一个接口,数个接口因为这个原因,最后导致了接口的速度很慢。 另外数据库连接池上限是固定的,连接时间过长,导致高并发下 :一旦连接...
  • Java 接口请求异步响应

    万次阅读 2018-01-08 17:38:56
    背景:接口请求的时候如果是同步,那么有时业务逻辑处理时间很长,请求就会超时! 所以需要在接口请求过来时,就先响应,再去执行业务逻辑。 1.创建一个Controller类用来接收接口请求 @RestController @...
  • 利用AOP监控Java接口响应超时

    千次阅读 2018-10-11 20:47:06
     服务化接口是提供服务的,接口正确性、稳定性是最最重要的,在保证正确的同时需要尽量提高接口响应时间。  有的团队会有专门的工具来对系统响应时间、吞吐量做监控,但如果团队没有这种“待遇”就需要自己来做...
  • Java反射遇到接口

    千次阅读 2019-07-20 21:25:11
    Java反射遇到接口 本文适合有点Java反射基础的同学,在Java反射调用方法时遇到接口参数是一件很蛋疼的事情。 在反射调用方法时需要传参数,像传递基本数据类型进去用就完事,传个对象进去怎么整都没关系,因为你在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,349
精华内容 39,739
关键字:

java接口耗时

java 订阅