Skip to main content

moregeek program

springboot2.x系列教程48--多数据源配置之aop动态切换数据源-多极客编程


SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源

作者:一一哥

在上一节中,我通过分包的方式实现了多数据源的配置,接下来我通过AOP切面的方式,带领大家实现第二种多数据源配置方式,该方式是在前面案例的基础上进行编写的。

一. 实现过程

1. 创建web项目

我们按照之前的经验,创建一个web程序,并将之改造成Spring Boot项目,具体过程略。

SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源_bc


2. 添加依赖包

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>

3. 创建application.yml配置文件

在该配置文件中,要进行两个数据库的配置,本案例中我们使用默认的HikariDataSource数据源。

spring:
main:
allow-bean-definition-overriding: true
datasource:
ds1:
url: jdbc:mysql://localhost:3306/db1?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: syc
driverClassName: com.mysql.jdbc.Driver
ds2:
url: jdbc:mysql://localhost:3306/db4?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
username: root
password: syc
driverClassName: com.mysql.jdbc.Driver
type: com.zaxxer.hikari.HikariDataSource
# type: com.alibaba.druid.pool.DruidDataSource
jpa:
database: mysql
show-sql: true
hibernate:
ddl-auto: update
naming:
physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
database-platform: org.hibernate.dialect.MySQL5Dialect

4. 创建数据库配置类

第一个数据库配置类

package com.yyg.boot.config.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description db1数据源配置类
*/
@ConfigurationProperties(prefix = "spring.datasource.ds1")
@Component("ds1Properties")
@Data
public class Ds1Properties {

private String url;

private String username;

private String password;

private String driverClassName;

}

第2个数据库配置类

package com.yyg.boot.config.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description db4数据源配置类
*/
@ConfigurationProperties(prefix = "spring.datasource.ds2")
@Component("ds2Properties")
@Data
public class Ds2Properties {

private String url;

private String username;

private String password;

private String driverClassName;

}

5. 注册数据源

我们在一个类中注册两个数据源就可以了。

package com.yyg.boot.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description 数据源的配置类
*/
@Configuration
public class DataSourceRegisterConfig {

/**
* 主数据源配置 ds1数据源
*/
@Primary
@Bean(name = "ds1Properties")
@ConfigurationProperties(prefix = "spring.datasource.ds1")
public DataSourceProperties ds1DataSourceProperties() {
return new DataSourceProperties();
}

/**
* 主数据源 ds1数据源
*/
@Primary
@Bean(name = "ds1DataSource")
public DataSource ds1DataSource(@Qualifier("ds1Properties") DataSourceProperties dataSourceProperties) {
//HikariDataSource","org.apache.tomcat.jdbc.pool.DataSource", "org.apache.commons.dbcp2.BasicDataSource
return dataSourceProperties.initializeDataSourceBuilder().build();
}

/**
* 第二个ds2数据源配置
*/
@Bean(name = "ds2Properties")
@ConfigurationProperties(prefix = "spring.datasource.ds2")
public DataSourceProperties ds2DataSourceProperties() {
return new DataSourceProperties();
}

/**
* 第二个ds2数据源
*/
@Bean("ds2DataSource")
public DataSource ds2DataSource(@Qualifier("ds2Properties") DataSourceProperties dataSourceProperties) {
return dataSourceProperties.initializeDataSourceBuilder().build();
}

}

6. 配置数据源、连接工厂、事务管理器、扫描dao目录

注意合理的使用@Primary注解!

配置第一个数据源管理器

package com.yyg.boot.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description 配置数据源、连接工厂、事务管理器、dao目录
*/
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
entityManagerFactoryRef = "managerFactory1", // 配置连接工厂
transactionManagerRef = "transactionManager1", // 配置事物管理器
basePackages = {"com.yyg.boot.dao.db01"} // 设置dao所在位置

)
public class ManagerFactory01Config {

/**
* 配置数据源,连接第1个数据源
*/
@Autowired
@Qualifier("ds1DataSource")
private DataSource ds1DataSource;

@Primary
@Bean(name = "managerFactory1")
public LocalContainerEntityManagerFactoryBean buildEntityManagerFactory1(EntityManagerFactoryBuilder builder) {
return builder
// 设置数据源
.dataSource(ds1DataSource)
//设置实体类所在位置.扫描所有带有 @Entity 注解的类
.packages("com.yyg.boot.entity")
// Spring会将EntityManagerFactory注入到Repository之中.有了 EntityManagerFactory之后,
// Repository就能用它来创建 EntityManager 了,然后 EntityManager 就可以针对数据库执行操作
.persistenceUnit("ds1PersistenceUnit")
.build();

}

/**
* 配置事务管理器
*/
@Bean(name = "transactionManager1")
public PlatformTransactionManager transactionManagerDatabase1(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(buildEntityManagerFactory1(builder).getObject());
}

}

配置第2个数据源管理器

package com.yyg.boot.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description 配置数据源、连接工厂、事务管理器、dao目录
*/
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
entityManagerFactoryRef = "managerFactory2", // 配置连接工厂
transactionManagerRef = "transactionManager2", // 配置事物管理器
basePackages = {"com.yyg.boot.dao.db02"} // 设置dao所在位置

)
public class ManagerFactory02Config {

/**
* 配置数据源,连接第2个数据源
*/
@Autowired
@Qualifier("ds2DataSource")
private DataSource ds2DataSource;

@Bean(name = "managerFactory2")
public LocalContainerEntityManagerFactoryBean buildEntityManagerFactory2(EntityManagerFactoryBuilder builder) {
return builder
// 设置数据源
.dataSource(ds2DataSource)
//设置实体类所在位置.扫描所有带有 @Entity 注解的类
.packages("com.yyg.boot.entity")
// Spring会将EntityManagerFactory注入到Repository之中.有了 EntityManagerFactory之后,
// Repository就能用它来创建 EntityManager 了,然后 EntityManager 就可以针对数据库执行操作
.persistenceUnit("ds2PersistenceUnit")
.build();

}

/**
* 配置事务管理器
*/
@Bean(name = "transactionManager2")
public PlatformTransactionManager transactionManagerDatabase1(EntityManagerFactoryBuilder builder) {
return new JpaTransactionManager(buildEntityManagerFactory2(builder).getObject());
}

}

7. 创建数据源类型

利用ThreadLocal确保线程安全性,每个线程之间不会相互影响。

package com.yyg.boot.datasource;

import lombok.extern.slf4j.Slf4j;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/7
* @Description 数据源类型
*/
@Slf4j
public class DataSourceType {

public enum SourceType {
/**
* 用户数据源
*/
DS_USER,
/**
* 商品数据源
*/
DS_SHOP
}

/**
* 使用ThreadLocal保证线程安全
*/
private static final ThreadLocal<SourceType> TYPES = new ThreadLocal<>();

/**
* 往当前线程里设置数据源类型
*/
public static void setDataSourceType(SourceType dataSourceType) {
if (dataSourceType == null) {
throw new NullPointerException();
}
log.warn("[设置当前数据源为]:" + dataSourceType);
TYPES.set(dataSourceType);
}

/**
* 获取数据源类型
*/
public static SourceType getDataSourceType() {
SourceType dataSourceType = TYPES.get() == null ? SourceType.DS_USER : TYPES.get();
log.warn("[当前数据源的类型为]:" + dataSourceType);
return dataSourceType;
}

/**
* 清空数据类型
*/
public static void removeDataSourceType() {
TYPES.remove();
}

}

8. 定义动态数据源

定义一个动态数据源,继承AbstractRoutingDataSource 抽象类,并重写determineCurrentLookupKey()方法。

AbstractRoutingDataSource这个类是实现多数据源的关键,作用是动态切换数据源。
在该类中有一个targetDataSources集合,该集合是AbstractRoutingDataSource的一个map类型的属性,其中key表示每个数据源的名字,value为每个数据源。
然后根据determineCurrentLookupKey()这个方法获取当前数据源在map中的key值,然后determineTargetDataSource()方法中动态获取当前数据源,如果当前数据源不存且默认数据源也不存在时就会抛出异常。

package com.yyg.boot.datasource;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/7
* @Description 动态切换数据源
*/
public class DynamicDataSource extends AbstractRoutingDataSource {

@Override
protected Object determineCurrentLookupKey() {
return DataSourceType.getDataSourceType();
}

}

9. 配置多个数据源

package com.yyg.boot.datasource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/7
* @Description 多数据源配置
*/
@Configuration
public class DynamicDataSourceConfig {

@Bean(name = "dynamicDataSource")
public DynamicDataSource dynamicDataSource(@Qualifier("ds1DataSource") DataSource ds1DataSource,
@Qualifier("ds2DataSource") DataSource ds2DataSource) {
Map<Object, Object> targetDataSource = new HashMap<>();
targetDataSource.put(DataSourceType.SourceType.DS_SHOP, ds1DataSource);
targetDataSource.put(DataSourceType.SourceType.DS_USER, ds2DataSource);
DynamicDataSource dataSource = new DynamicDataSource();
dataSource.setTargetDataSources(targetDataSource);
dataSource.setDefaultTargetDataSource(ds2DataSource);
return dataSource;
}

}

10. 定义AOP切面

package com.yyg.boot.datasource;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/7
* @Description Description
*/
@Aspect
@Component
@Slf4j
public class DataSourceAop {

@Before("execution(* com.yyg.boot.service.impl.GoodsServiceImpl.*(..))")
public void setDataSource01() {
log.warn("db01商品数据源");
DataSourceType.setDataSourceType(DataSourceType.SourceType.DS_SHOP);
}

@Before("execution(* com.yyg.boot.service.impl.UserServiceImpl.*(..))")
public void setDataSource02() {
log.warn("db02用户数据源");
DataSourceType.setDataSourceType(DataSourceType.SourceType.DS_USER);
}

}

11. 创建Entity实体类

Goods商品类

package com.yyg.boot.entity;

import lombok.Data;

import javax.persistence.*;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description db1中的商品表
*/
@Entity
@Table(name = "goods")
@Data
public class Goods {

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long id;

private String name;

}

User用户类

package com.yyg.boot.entity;

import lombok.Data;

import javax.persistence.*;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description db4中的用户表
*/
@Entity
@Table(name = "user")
@Data
public class User {

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Long id;

private String username;

private String birthday;

private String sex;

private String address;

}

12. 创建Dao层代码

GoodsRepository类

package com.yyg.boot.dao.db01;

import com.yyg.boot.entity.Goods;
import com.yyg.boot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description Description
*/
@Repository
public interface GoodsRepository extends JpaRepository<Goods, Long>,JpaSpecificationExecutor<User> {
}

UserRepository类

package com.yyg.boot.dao.db02;

import com.yyg.boot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description Description
*/
@Repository
public interface UserRepository extends JpaRepository<User, Long>,JpaSpecificationExecutor<User> {
}

13. 创建Service代码

UserServiceImpl实现类

package com.yyg.boot.service.impl;

import com.yyg.boot.dao.db02.UserRepository;
import com.yyg.boot.entity.User;
import com.yyg.boot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/7
* @Description Description
*/
@Service
public class UserServiceImpl implements UserService {

@Autowired
private UserRepository userRepository;

@Override
public List<User> findAll() {
return userRepository.findAll();
}

}

GoodsServiceImpl实现类

package com.yyg.boot.service.impl;

import com.yyg.boot.dao.db01.GoodsRepository;
import com.yyg.boot.dao.db02.UserRepository;
import com.yyg.boot.entity.Goods;
import com.yyg.boot.entity.User;
import com.yyg.boot.service.GoodsService;
import com.yyg.boot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/7
* @Description Description
*/
@Service
public class GoodsServiceImpl implements GoodsService {

@Autowired
private GoodsRepository goodsRepository;

@Override
public List<Goods> findAll() {
return goodsRepository.findAll();
}

}

14. 创建Controller接口

package com.yyg.boot.web;

import com.yyg.boot.entity.Goods;
import com.yyg.boot.entity.User;
import com.yyg.boot.service.GoodsService;
import com.yyg.boot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description Description
*/
@RestController
public class GoodsController {

@Autowired
private UserService userService;

@Autowired
private GoodsService goodsService;

@GetMapping(value = "/users")
public List<User> users() {
return userService.findAll();
}

@GetMapping(value = "/goods")
public List<Goods> goods() {
return goodsService.findAll();
}

}

15. 创建入口类

package com.yyg.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
* @Author 一一哥Sun
* @Date Created in 2020/4/3
* @Description Description
*/
@SpringBootApplication
public class DataSourceApplication {

public static void main(String[] args){
SpringApplication.run(DataSourceApplication.class,args);
}

}

16. 完整项目结构

SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源_spring_02


17. 运行测试

我们首先测试一下goods接口,查询的是db1数据库里的数据。

SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源_spring_03


对应的db1数据库里的数据。

SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源_bc_04

然后再测试一下users接口,查询的是db4数据库里的数据。

SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源_bc_05

对应数据库里的数据。

SpringBoot2.x系列教程48--多数据源配置之AOP动态切换数据源_spring_06


至此,我们在Spring Boot中,利用JPA实现了配置两个数据源,其实也可以以此类推,配置3个,4个乃至更多的数据源!


 

©著作权归作者所有:来自51CTO博客作者一一哥Sun的原创作品,请联系作者获取转载授权,否则将追究法律责任

15-多极客编程

15_Java筑基之Object类、多态一. Object类Object类是类层次结构的根类,每个类都使用Object作为超类(父类).1. equals()方法指示其他某个对象是否与此对象“相等”.示例代码;/*** 学生类*/public class Student extends Object{ String stuNo; String stuName; int age;

day19-多极客编程

Vue教程之Vue实例的生命周期一.什么是生命周期Vue 实例有一个完整的生命周期,也就是从开始创建、初始化数据、编译模板、挂载 DOM、渲染→更新→渲染、卸载等一系列过程,我们称这是 Vue 的生命周期。通俗说就是 Vue 实例从创建到销毁的过程,就是生命周期。在 Vue 的整个生命周期中,它提供了一系列的事件,可以让我们在事件触发时注册 JS 方法,可以让我们用自己注册的 JS 方法控制整个大

cdn的功能及原理-多极客编程

为了缓解互联网用户增加与服务等待时间增长的矛盾,在增加互联网核心交换网、汇聚网与接入网带宽同时,MIT研究者于1998年提出了内容分发网络(ContentDelivery Network,CDN)的概念,开始了CDN技术及其应用的研究。CDN系统设计的基本思路可以归纳为两点:如果某个内容被很多用户关注,就将它缓存在离用户最近的节点中。选择最适合的缓存节点为用户提供服务。选择最合适的缓存节点的过程中

day19-多极客编程

Vue教程之Vue表单输入一.什么是双向数据绑定Vue.js 是一个 MVVM 框架,即数据双向绑定,即当数据发生变化的时候,视图也就发生变化,当视图发生变化的时候,数据也会跟着同步变化。这也算是 Vue.js 的精髓之处了。值得注意的是,我们所说的数据双向绑定,一定是对于 UI 控件来说的,非 UI 控件不会涉及到数据双向绑定。单向数据绑定是使用状态管理工具的前提。如果我们使用 ​​vuex​​

zookeeper分布式一致性算法--2pc、3pc及其应用-多极客编程

2PC、3PC的基本概念2PC,3PC主要是基于分布式事务的分布式一致性算法(因为分布式事务也可能会导致数据的不一致问题,这跟副本的不一致性从大类上看是都归于数据的不一致)。在分布式系统中,各个节点之间在物理上相互独立,通过网络进行沟通和协调。由于存在事务机制,可以保证每个独立节点上的数据操作可以满足ACID。但是,相互独立的节点之间无法准确的知道其他节点中的事务执行情况。所以从理论上讲,两台机器

matlab图像形态学处理—开操作和闭操作-多极客编程

✅作者简介:热爱科研的算法开发者,Python、Matlab项目可交流、沟通、学习。 🍎个人主页:算法工程师的学习日志昨晚分享了图像形态学处理—开操作和闭操作的基本原理,同时基于Python的OpenCV实现了对应的图像处理,本文分享一下基于Matlab的图像形态学处理—开操作和闭操作。传送门:​​Python OpenCV 形态学应用—图像开运算与闭运算​​%开启和闭合操作 用 MATLAB实现

15-多极客编程

15_Java筑基之Object类、多态一. Object类Object类是类层次结构的根类,每个类都使用Object作为超类(父类).1. equals()方法指示其他某个对象是否与此对象“相等”.示例代码;/*** 学生类*/public class Student extends Object{ String stuNo; String stuName; int age;

day19-多极客编程

Vue教程之Vue实例的生命周期一.什么是生命周期Vue 实例有一个完整的生命周期,也就是从开始创建、初始化数据、编译模板、挂载 DOM、渲染→更新→渲染、卸载等一系列过程,我们称这是 Vue 的生命周期。通俗说就是 Vue 实例从创建到销毁的过程,就是生命周期。在 Vue 的整个生命周期中,它提供了一系列的事件,可以让我们在事件触发时注册 JS 方法,可以让我们用自己注册的 JS 方法控制整个大

36-zabbix使用监控模板监控主机流程-多极客编程

使用现有模板和监控项监控主机流程在被监控的主机上安装Zabbix Agent ,建议和 Zabbix Server 同一个版本配置 Zabbix agent的配置文件关键两项,并重启服务生效 --> Server = <Zabbix_Server_IP> --> Hostname=<本机IP>在Zabbix Server 上使用 zabbix_get 工具测试是

day19-多极客编程

Vue教程之Vue表单输入一.什么是双向数据绑定Vue.js 是一个 MVVM 框架,即数据双向绑定,即当数据发生变化的时候,视图也就发生变化,当视图发生变化的时候,数据也会跟着同步变化。这也算是 Vue.js 的精髓之处了。值得注意的是,我们所说的数据双向绑定,一定是对于 UI 控件来说的,非 UI 控件不会涉及到数据双向绑定。单向数据绑定是使用状态管理工具的前提。如果我们使用 ​​vuex​​

wireshark的使用(抓包、过滤器)-多极客编程

1 Wireshark是世界上最流行的网络分析工具。这个强大的工具可以捕捉网络中的数据,并为用户提供关于网络和上层协议的各种信息。与很多其他网络工具一样,Wireshark也使用pcap network library来进行封包捕捉。可po jie局域网内QQ、邮箱、msn、账号等的密码!!    wireshark的原名是Ethereal,新名字是2006年起用的。当时Ethereal的主要开发

prometheus监控之检查工具promtool debug-多极客编程

一、概述属于这个类别的子命令允许从运行的Prometheus服务器提取调试数据,以便对其进行分析。接下来我们将演示如何使用它们。Promtool 在 debug 方面一个有 3 个子命令,分别用来获取profiling debug信息、获取metric debug信息、获取所有debug信息、对规则文件进行单元测试二、Debug1、获取profiling debug信息使用 这个命令来获取 Pro