CAT链路追踪从入门到实战（看这一篇就够了）

 mvn clean install -Dmaven.test.skip=true 

 mkdir /data/appdatas/cat/
 chmod -R 777 /data/appdatas/cat/

 <?xml version="1.0" encoding="utf-8"?>
 <config mode="client">
     <servers>
         <server ip="127.0.0.1" port="2280" http-port="8080"/>
     </servers>
 </config>

 <?xml version="1.0" encoding="utf-8"?>  
 <data-sources>
 <data-source id="cat">
     <maximum-pool-size>3</maximum-pool-size>
     <connection-timeout>1s</connection-timeout>
     <idle-timeout>10m</idle-timeout>
     <statement-cache-size>1000</statement-cache-size>
     <properties>
         <driver>com.mysql.jdbc.Driver</driver>
         <url><![CDATA[jdbc:mysql://127.0.0.1:3306/cat]]></url>  <!-- 请替换为真实数据库URL及Port  -->
         <user>root</user>  <!-- 请替换为真实数据库用户名  -->
         <password>123456</password>  <!-- 请替换为真实数据库密码  -->
         <connectionProperties><![CDATA[useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&socketTimeout=120000]]></connectionProperties>
     </properties>
 </data-source>
 </data-sources>

 <Connector port="8080" protocol="HTTP/1.1"
         URIEncoding="utf-8"    connectionTimeout="20000"
             redirectPort="8443" />  <!-- 增加  URIEncoding="utf-8"  -->  

 CATALINA_OPTS="-Xms1024m -Xmx2048m -Xss1024K  -XX:MetaspaceSize=512m -XX:MaxMetaspaceSize=1024m"

 bash startup.sh

 <dependencies>
     <!-- spring boot 依赖 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <!-- Nacos服务注册发现依赖 -->
     <dependency>
         <groupId>com.alibaba.cloud</groupId>
         <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
     </dependency>
     <!-- Spring Boot 监控组件依赖 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-actuator</artifactId>
     </dependency>
     <!-- CAT 组件依赖-->
     <dependency>
         <groupId>com.dianping.cat</groupId>
         <artifactId>cat-client</artifactId>
         <version>3.0.1</version>
     </dependency>
 </dependencies>

 @SpringBootApplication
 @EnableDiscoveryClient
 @ComponentScan(basePackages = {"com.xiaobear"})
 @RestController
 public class CatGateWayApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(CatGateWayApplication.class, args);
     }
 
     @Resource
     private RestTemplate restTemplate;
 
     /**
      * 指向订单服务的接口
      */
     @Value("${service2.address:localhost:8082}")
     private String serviceAddress;
 
     /**
      * 模拟正常的请求
      * @return
      * @throws Exception
      */
     @RequestMapping("/gateway")
     public String gateway() throws Exception {
         Thread.sleep(100);
         String response = restTemplate.getForObject("http://" + serviceAddress + "/order", String.class);
         return "gateway response ==> " + response;
     }
 
     /**
      * 模拟一个请求异常
      * @return
      * @throws Exception
      */
     @RequestMapping("/timeout")
     public String timeout() throws Exception {
         Transaction t = Cat.newTransaction(CatConstants.TYPE_URL, "timeout");
         try {
             Thread.sleep(100);
             String response = restTemplate.getForObject("http://" + serviceAddress + "/timeout", String.class);
             return response;
         }catch(Exception e) {
             Cat.getProducer().logError(e);
             t.setStatus(e);
             throw e;
         }finally {
             t.complete();
         }
 
     }
 
     @Bean
     RestTemplate restTemplate() {
         RestTemplate restTemplate = new RestTemplate();
         // 保存和传递调用链上下文
         restTemplate.setInterceptors(Collections.singletonList(new CatRestInterceptor()));
         return restTemplate;
     }
 }

 server:
   port: 8081
 spring:
   application:
     name: cat-gateway
   cloud:
     nacos:
       discovery:
         ip: 127.0.0.1:8848
 
 #暴露端口
 management:
   endpoint:
     web:
       exposure:
         include: ‘*’

 @SpringBootApplication
 @EnableDiscoveryClient
 @RestController
 @ComponentScan("com.xiaobear")
 public class CatAccountApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(CatAccountApplication.class, args);
     }
 
     /**
      * 提供账户服务接口
      * @return
      * @throws Exception
      */
     @RequestMapping("/account")
     public String account() throws Exception {
         Thread.sleep(150);
         return "account success";
     }
 }

 @SpringBootApplication
 @EnableDiscoveryClient
 @RestController
 @ComponentScan("com.xiaobear")
 @Slf4j
 public class CatOrderApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(CatOrderApplication.class, args);
     }
 
     @Autowired
     RestTemplate restTemplate;
     /**
      * Account账户服务
      */
     @Value("${service3.address:localhost:8083}")
     String serviceAddress3;
     /**
      * stock库存服务
      */
     @Value("${service4.address:localhost:8084}")
     String serviceAddress4;
 
     /**
      * 异常测试端口
      */
     private static final int MOCK_PORT = 8765;
 
 
     /**
      * 提供下单接口
      * @return
      * @throws InterruptedException
      */
     @RequestMapping("/order")
     public String service2MethodInController() throws InterruptedException {
         Thread.sleep(200);
         // 调用账户服务以及库存服务
         String service3 = restTemplate.getForObject("http://" + serviceAddress3 + "/account", String.class);
         String service4 = restTemplate.getForObject("http://" + serviceAddress4 + "/stock", String.class);
         //打印返回结果
         return String.format("Calling order service[order success] ==> Calling Account Service [%s]  ==> Calling Customer Service [%s]", service3, service4);
     }
 
     /**
      * 模拟异常超时接口
      * @return
      * @throws InterruptedException
      */
     @RequestMapping("/readtimeout")
     public String connectionTimeout() throws InterruptedException {
         Transaction t = Cat.newTransaction(CatConstants.TYPE_CALL, "connectionTimeout");
         //睡眠500ms
         Thread.sleep(500);
         try {
             log.info("Calling a missing service");
             //远程调用异常端口
             restTemplate.getForObject("http://localhost:" + MOCK_PORT + "/readtimeout", String.class);
             return "Should blow up";
         } catch(Exception e) {
             t.setStatus(e);
             Cat.getProducer().logError(e);
             throw e;
         } finally {
             t.complete();
         }
     }
 
     @Bean
     RestTemplate restTemplate() {
         SimpleClientHttpRequestFactory clientHttpRequestFactory = new SimpleClientHttpRequestFactory();
         clientHttpRequestFactory.setConnectTimeout(2000);
         clientHttpRequestFactory.setReadTimeout(3000);
         RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory);
 
         // 保存和传递调用链上下文
         restTemplate.setInterceptors(Collections.singletonList(new CatRestInterceptor()));
 
         restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {
             @Override public boolean hasError(ClientHttpResponse response)
                     throws IOException {
                 try {
                     return super.hasError(response);
                 } catch (Exception e) {
                     return true;
                 }
             }
 
             @Override public void handleError(ClientHttpResponse response)
                     throws IOException {
                 try {
                     super.handleError(response);
                 } catch (Exception e) {
                     log.error("Exception [" + e.getMessage() + "] occurred while trying to send the request", e);
                     throw e;
                 }
             }
         });
         return restTemplate;
     }
 }

 @SpringBootApplication
 @EnableDiscoveryClient
 @ComponentScan("com.xiaobear")
 @RestController
 public class CatStockApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(CatStockApplication.class, args);
     }
 
     /**
      * 提供库存接口
      * @return
      * @throws Exception
      */
     @RequestMapping("/stock")
     public String stock() throws Exception {
         Thread.sleep(200);
         return "stock success";
     }
 }

 gateway service ==> Calling order service[order success] ==> Calling Account Service [account success] ==> Calling Customer Service [stock success]