Jaeger, Spring 和 AspectJ 进行性能问题定位

最新推荐文章于 2025-11-14 17:59:51 发布
原创 最新推荐文章于 2025-11-14 17:59:51 发布 · 621 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#压力测试

本文指导如何利用Jaeger和AspectJ在Springboot项目中定位复杂的API性能问题，包括安装Jaeger、配置Spring与AspectJ、编写Aspect并设置AOP切点，最终通过Opentracing追踪调用链以快速定位瓶颈。

Jaeger, Spring 和 AspectJ 进行性能问题定位


时间有限， 各方面比较粗糙， 多担待，能看懂，能解决问题就行。

问题

性能测试过程中， 一般会发现某些API 性能比较差， 响应时间显著高于其他 其他API, 所以需要确定 这些API 的响应时间高的原因是什么，
一般这样的API 里面有超级复杂的业务逻辑， 嵌套调用其他api, server ， 等等， 涉及到的方法调用可能有成百上千。

如何快速定位性能问题根源呢？

如何定位问题

性能问题一般是压测发现的， 首先单独调用一个那个api, 看看响应时间是否正常， 如果单独调用正常， 压测时响应时间高， 一般是server 相关的问题，或者锁相关的问题。
如果单独调用响应时间就很高， 那就需要定位这个api 时间主要花费在哪里， 如何定位呢

  1. 最直接的方法是， 猜测某些大的方法， 加log 输出所用时间， 然后逐步追踪， 最后确定是哪里的问题。 这需要不断地改代码加log, 重新测试
  2. 如果方法比较多 而且没有头绪，，或快速准确定位问题， 可以用 Jaeger + AspectJ（+Spring） 来定位问题
    用AspectJ 拦截系统涉及到的类、方法， 用AspectJ 表达式定义多个cutpoint ， 然后用aspect 拦截， 生成 opentracing 的span, 把这些span 发到jaeger 中， 用jaeger 提高的 UI, 可以快速清晰地定位性能问题根源。

Jaeger 安装

Jaeger 官网 找到 docker-compose , 直接启动

http://localhost:16686 查看jaeger UI
程序连接 jaeger agent udp 端口6831

docker run -d --name jaeger -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 -p 5775:5775/udp -p 6831:6831/udp -p 6832:6832/udp -p 5778:5778 -p 16686:16686 -p 14268:14268 -p 14250:14250 jaegertracing/all-in-one:1.27

D:>docker run -d --name jaeger -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 -p 5775:5775/udp -p 6831:6831/udp -p 6832:6832/udp -p 5778:5778 -p 16686:16686 -p 14268:14268 -p 14250:14250 jaegertracing/all-in-one:1.27
Unable to find image ‘jaegertracing/all-in-one:1.27’ locally
1.27: Pulling from jaegertracing/all-in-one
a0d0a0d46f8b: Pull complete
b45576136ee2: Pull complete
d22e8500bf73: Pull complete
1a972b89c2b0: Pull complete
Digest: sha256:8d0bff43db3ce5c528cb6f957520511d263d7cceee012696e4afdc9087919bb9
Status: Downloaded newer image for jaegertracing/all-in-one:1.27
d0a675654e6efe92cf035b4e210c531ee7e439b978ceda6e427914930b39ac8f

在这里插入图片描述

AspectJ +Springboot

需要用到 spring-instrument, spring-aspects， opentracing-spring-jaeger-starter ,
opentracing-spring-jaeger-starter 里有jaeger 自动配置, 会自动配置好全局的tracer, 然后其他代码里直接注入就可以使用了，
spring aop 只能拦截beans, 所以我们需要用aspectj 把 所有代码都能拦截到， 所以需要写个aspectj 的aspect 进行拦截，
里面用Aspectj 定义多个cutpoint, 用spring 的@configurable 功能(因为aspect 不是bean) 把tracer 注入到aspect,
然后在用around 拦截个个方法调用， 在around 中生成每个方法的span, 并于父span 管理，同时可以把方法发生的异常也记录到span log 中，
配置要点：

  1. spring boot Application 上加上
    @EnableLoadTimeWeaving
    @EnableSpringConfigured
  2. Jaeger 连接参数

application.properties

spring.application.name=demo-app
opentracing.jaeger.enableB3Propagation=true
#the jaeger agent host
opentracing.jaeger.udpSender.host=localhost
##the jaeger agent port
opentracing.jaeger.udpSender.port=6831
opentracing.jaeger.constSampler.decision=true

  1. 定义aspect
package com.nick.demo.aspect;

import io.opentracing.Scope;
import io.opentracing.Span;
import io.opentracing.Tracer;
import io.opentracing.tag.Tags;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.beans.factory.annotation.Value;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

@Aspect
@Configurable
public class MyAspect {
    private static final Logger log= LoggerFactory.getLogger(MyAspect.class);

    @Autowired
    Tracer tracer;
    @Value("${spring.application.name}")
    String appName;

    @Pointcut("within(com.nick.demo.model..*) && execution(public * *(..))")
    public void point1(){

    }
    @Pointcut("within(com.nick.demo.service..*) && execution(public * *(..))")
    public void point2(){

    }
    @Pointcut("execution(public * com.nick.demo.service2.IRoleService+.*(..))")
    public void point3(){

    }
    @Pointcut("execution(public * com.nick.demo.api..*.*(..))")
    public void point4(){

    }
    @Around("point1() || point2() ||point3() ||point4()")
    public Object process(ProceedingJoinPoint point) throws Throwable {
        Span span=null;
        Scope scope=null;

        try{
            if(tracer!=null){
                Object object=point.getTarget();
                JoinPoint.StaticPart staticPart=point.getStaticPart();
                String clazz=null;
                String method=null;
                if(object!=null){
                    clazz=object.getClass().getName();
                    method=point.getSignature().getName();
                }else if(staticPart!=null){
                    clazz=staticPart.getSourceLocation().getFileName();
                    method=staticPart.getSignature().getName();
                }
                //if can not dermine class/method, skip
                if(clazz==null){
                    return point.proceed();
                }

                Span parent=tracer.activeSpan();
                Tracer.SpanBuilder spanBuilder=tracer.buildSpan(clazz+"."+method)
                        .withTag(Tags.COMPONENT.getKey(),appName)
                        .withTag("class",clazz)
                        .withTag("method",method);
                try{
                    spanBuilder.withTag("args", Arrays.toString(point.getArgs()));
                }catch (Throwable t){
                    //log.warn
                    log.warn("",t);

                }
                if(parent!=null){
                    spanBuilder.asChildOf(parent);
                }
                span=spanBuilder.start();
            }
            if(span!=null&&tracer!=null){
                scope=tracer.scopeManager().activate(span);
            }
            return point.proceed();
        }catch (Throwable t){
            if(span!=null){
                Map extInf=new HashMap();
                extInf.put("event",Tags.ERROR.getKey());
                extInf.put("error.exception",t);
                span.log(extInf);
                Tags.ERROR.set(span,true);
            }
            throw  t;
        }finally {
            if(scope!=null){
                scope.close();
            }
            if(span!=null){
                span.finish();
            }
        }
    }
}
  1. 添加 META-IN/aop.xml,
<aspectj>

    <aspects>
        <!-- declare two existing aspects to the weaver -->
        <aspect name="com.nick.demo.aspect.MyAspect"/>
    </aspects>

    <weaver options="-verbose">
        <!-- Weave types that are within the com.nick.demo.*
             packages.
           NOTE: com.nick.demo.aspect.MyAspect  需要包含在被weave 的包里，
           否则会报 no such method aspectof 异常
              -->
        <include within="com.nick.demo.api.*"/>
        <include within="com.nick.demo.model.*"/>
        <include within="com.nick.demo.service.*"/>
        <include within="com.nick.demo.service2.*"/>
        <include within="com.nick.demo.aspect.*"/>

    </weaver>

</aspectj>

参考下面链接：
https://www.eclipse.org/aspectj/doc/next/devguide/ltw-configuration.html
3. jvm 启动参数指定 ,

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.5.4</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.nick</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>8</java.version>
		<spring-cloud.version>2020.0.3</spring-cloud.version>
	</properties>
	<dependencies>

<!--		<dependency>-->
<!--			<groupId>org.springframework.cloud</groupId>-->
<!--			<artifactId>spring-cloud-starter-function-web</artifactId>-->
<!--			<version>3.1.3</version>-->
<!--		</dependency>-->



		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-instrument</artifactId>
		</dependency>
		<dependency>
			<groupId>io.opentracing.contrib</groupId>
			<artifactId>opentracing-spring-jaeger-starter</artifactId>
			<version>3.3.1</version>
		</dependency>
	</dependencies>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<version>2.5.4</version>
				<configuration>
					<jvmArguments> -javaagent:${project.build.directory}/lib/aspectjweaver.jar   -javaagent:${project.build.directory}/lib/spring-instrument.jar</jvmArguments>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-dependency-plugin</artifactId>
				<version>3.2.0</version>
				<executions>
					<execution>
						<id>copy</id>
						<phase>package</phase>
						<goals>
							<goal>copy</goal>
						</goals>
					</execution>
				</executions>
				<configuration>
					<artifactItems>
						<artifactItem>
							<groupId>org.springframework</groupId>
							<artifactId>spring-instrument</artifactId>
							<version>${spring-framework.version}</version>
							<type>jar</type>
							<overWrite>false</overWrite>
							<outputDirectory>${project.build.directory}/lib</outputDirectory>
							<destFileName>spring-instrument.jar</destFileName>
						</artifactItem>
						<artifactItem>
							<groupId>org.aspectj</groupId>
							<artifactId>aspectjweaver</artifactId>
							<version>${aspectj.version}</version>
							<type>jar</type>
							<overWrite>false</overWrite>
							<outputDirectory>${project.build.directory}/lib</outputDirectory>
							<destFileName>aspectjweaver.jar</destFileName>
						</artifactItem>
					</artifactItems>
					<outputDirectory>${project.build.directory}/wars</outputDirectory>
					<overWriteReleases>false</overWriteReleases>
					<overWriteSnapshots>true</overWriteSnapshots>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

运行

mvn spring-boot:run

请求api : http://localhost:8080/aip/hello/nick , 多请求几次

在这里插入图片描述

查看 Jaeger UI, 可以看到， api 的调用链， 及各个方法用的时间， 轻松定位 性能问题。

代码链接： https://github.com/springnick/pfmIssue.git

在这里插入图片描述

在这里插入图片描述

Spring Cloud集成jaeger
qqq125536039的博客
01-06 2550
Spring Cloud集成jaeger 介绍 Jaeger 是Uber推出的一款开源分布式追踪系统，兼容OpenTracing API。分布式追踪系统用于记录请求范围内的信息。例如，一次远程方法调用的执行过程和耗时。是我们排查系统问题和系统性能的利器.它用于监视和诊断基于微服务的分布式系统，包括： 分布式上下文传播 分布式交易监控 根本原因分析 服务依赖性分析 性能/延迟优化 为什么使用Ja...
使用 AOP 在 Spring Boot 中实现跟踪和日志记录
adminmail的博客
12-23 1516
此外，Jaeger、Zipkin 和 OpenTelemetry 等分布式跟踪工具可以帮助您跟踪跨多个服务的请求，从而使微服务中的调试和监控变得更加容易。在现代应用程序中，尤其是使用微服务构建的应用程序，跟踪和日志记录在跟踪流经各种服务的请求方面起着至关重要的作用。从前端生成的代码在 Spring Boot 应用程序中实现跟踪和日志记录，我们还将探索在微服务环境中进行分布式跟踪的选项。有助于追踪用户在系统中的旅程，但在更复杂的微服务架构中，通常需要分布式跟踪工具才能获得跨多个服务的整体视图。
Android性能优化神器-AspectJ
verymrq的博客
09-19 1223
一、AOP AOP:面向切面编程(Aspect-Oriented Programming)。 如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。 比如有三个模块：登陆、转账、大文件上传，现在需要加入性能检测功能，统计这三个模块每个方法耗时多少。 OOP思想做法是设计一个性能检测模块，提供接口供这三个模块调用。这样每个模块都要调用性能检测模块的接...
使用 Spring Cloud Jaeger 进行分布式跟踪
stone1290的专栏
02-05 1174
Jaeger 是一种开源分布式跟踪机制，有助于跟踪分布式系统中的请求。它基于OpenTracing规范，是云原生计算基金会 (CNCF)的一部分。
aop aspectj_AOP @ Work，使用AspectJ进行性能监视，第1部分
cusi77914的博客
06-30 250
存档日期：2019年5月15日 | 首次发布：2005年9月13日 Ron Bodkin向您展示了如何将AspectJ和JMX结合起来以一种灵活，模块化的性能监控方法，告别分散而纠结的监控代码。 在两部分的第一部分中，Ron使用Glassbox Inspector开源项目中的源代码和构想来帮助您构建一个监视系统，该监视系统提供相关信息来识别特定问题，但开销足够低，可用于生产环境。 此内...
使用Spring AOP快速定位线上项目性能问题
程铭程铭你快成名的博客
08-01 6445
前提 这篇文章以Spring AOP为例，介绍如何快速定位执行效率较低的方法，从而解决服务运行较慢的问题。如果不是很了解Spring AOP的小伙伴，可以先看一下我的这篇文章：Spring学习之AOP，然后再回来继续看这篇文章。 背景 最近线上项目总是收到客户发来的邮件，吐槽有一些动作要等好几十秒才能有反应，问我们是不是项目出什么问题了。看到邮件的第一反应就想到可能有一些方法执行的时间太长了，导致...
性能优化术：利用Spring AOP减少代码冗余
[性能优化术：利用Spring AOP减少代码冗余](https://foxminded.ua/wp-content/uploads/2023/05/image-36.png) # 1. 面向切面编程（AOP）的理论基础 在现代软件开发领域，面向切面编程（AOP）已成为一种重要的编程...
Spring Boot跨服务调用TraceId传播失败的原因与MDC正确用法
最新发布
weixin_41455464的博客
11-14 968
遗漏传递和命名不一致是 HTTP Header 传递 TraceId 常见的错误。线程切换时 MDC 内容丢失和 MDC 内存泄漏是 MDC 使用中的常见问题。使用 AOP 简化 MDC 操作，并考虑使用现成的 Trace 系统，可以提升效率。
Spring AOP与Spring Boot整合秘籍
![Spring AOP与Spring Boot整合秘籍]... Spring AOP和Spring Boot简介 ## 1.1 Spring AOP简介 Spring AOP是Spring框架的一个重要模块，提供了面
mybatis-plus中无法引入性能分析拦截器
10-23
如果你想添加性能分析功能，比如像Spring AOP提供的AspectJ来进行代码切面，可以尝试以下步骤： 1. 首先，你需要在项目中引入相关的AOP库，如Spring AOP或者Shiyanliang的APM（如Jaeger、SkyWalking等）。 2. 创建...
SpringBoot 2.4.X 接入Jaeger
kylin
08-16 1559
SpringBoot 2.4.X 接入，建议 springcloud 版本 2020.0.X，该版本支持 kafka 接入调用链 步骤一：POM 文件中引入jaeger依赖 <dependency> <groupId>io.opentracing.contrib</groupId> <artifactId>opentracing-spring-jaeger-cloud-starter</artifactId> <version>3
Springboot集成Jaeger 链路追踪
xieshanwu的博客
05-07 4333
本文只实现单个项目日志打印traceId,分布式系统全局trace暂时没考虑 项目地址：java-spring-jaeger 第一步：引入依赖 <dependency> <groupId>io.opentracing.contrib</groupId> <artifactId>opentracing-spring-jaeger-web-starter</artifactId> <version>3.3.1
Spring Cloud集成Zipkin/Jaeger
yuehua00的专栏
01-16 331
以上是Spring Cloud集成Zipkin或Jaeger的基本步骤。通过这种方式，你可以对微服务之间的调用链路进行跟踪，从而更好地监控和优化系统的性能。如果你使用的是Spring Boot和Spring Cloud，那么这些工具的集成将非常简单和高效。
android 配置aspect_强大！ASM 插桩实现 Android 端无埋点性能监控！
weixin_39958911的博客
12-11 281
code小生一个专注大前端领域的技术平台公众号回复Android加入安卓技术群作者：kyleada_dl， 链接：https://blog.youkuaiyun.com/wangkai0681080/article/details/82659516背景当我们需要了解页面加载性能时，可以通过手动埋点的方式记录页面阶段耗时、网络耗时、数据库加载耗时以及其他耗时点，配合slardar平台，能直观地了解到...
Spring Boot PostConsruct
more time
03-27 985
先 autowired autowired 之后再执行 package com.example.demo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.SpringApplication; import org.springframework.boot...
jaeger详细使用说明（全网最全面和深入）
wjj304999133的博客
08-14 4535
网上一直没有jaeger的全部详细资料，这次我整理好了、并且自己实际部署成功上线后，才编辑好此文章免费分享。
一起来学SpringCloud之整合Jaeger链路追踪
weixin_68320784的博客
05-23 1385
前言 大家好，一直以来我都本着用最通俗的话理解核心的知识点, 我认为所有的难点都离不开基础知识的铺垫。目前正在出一个SpringCloud长期系列教程，从入门到进阶, 篇幅会较多~ 适合人群 有一定的Java基础 想尝试微服务开发 有SpringBoot开发基础 想学习或了解SpringCloud 想提高自己的同学 大佬可以绕过 ~ 背景 如果你是一路看过来的，很高兴你能够耐心看完。之前带大家学了Springboot这门框架，熟练掌握了单体应用的开发，如今微服务开发盛行...
AOP：切面编程框架：AspectJ(四)监控应用冷热启动耗时与生命周期耗时
C++ JAVA的专栏
05-12 452
参看下面这篇文章 深入探索编译插桩技术（二、AspectJ） - 掘金
【亲测免费】 使用Jaeger进行Spring Boot应用的分布式追踪
gitblog_00535的博客
08-20 605
使用Jaeger进行Spring Boot应用的分布式追踪 项目介绍 Jaeger是Uber开发的一个分布式的追踪系统，它支持OpenTracing API，用于收集服务之间的追踪数据，帮助开发者分析和理解分布式系统的执行流程。此教程基于OpenTracing Contrib项目，该库提供了与Spring Boot集成的便利方式，使得在Spring生态系统中实现Jaeger追踪变得简单直观。 项目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值