详细代码举例：java后端做一个运维监控，中台接口要能记录服务调用次数，服务调用来源 ，自定义注解，发送消息到MQ，数据交互平台从MQ消费消息，插入到数据库

好的，以下是一个示例代码，用于记录服务调用次数和调用来源，并使用自定义注解和MQ将数据发送到数据交互平台：

首先，我们需要引入Prometheus Java客户端库和RabbitMQ客户端库，可以在pom.xml文件中添加以下依赖：

<dependency>
  <groupId>io.prometheus</groupId>
  <artifactId>simpleclient</artifactId>
  <version>0.11.0</version>
</dependency>
<dependency>
  <groupId>io.prometheus</groupId>
  <artifactId>simpleclient_httpserver</artifactId>
  <version>0.11.0</version>
</dependency>
<dependency>
  <groupId>com.rabbitmq</groupId>
  <artifactId>amqp-client</artifactId>
  <version>5.11.0</version>
</dependency>

然后，我们可以编写一个自定义注解`@Monitor`，用于标识需要监控的服务方法，并编写一个切面`MonitorAspect`，在方法调用前后记录服务调用次数和调用来源，并将数据发送到RabbitMQ：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import io.prometheus.client.Counter;
import io.prometheus.client.exporter.HTTPServer;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

@Aspect
public class MonitorAspect {
  // 创建一个计数器，用于记录服务调用次数
  private static final Counter requestCount = Counter.build()
          .name("service_request_count")
          .help("Number of requests received")
          .register();

  // 创建一个计数器，用于记录服务调用来源
  private static final Counter requestSource = Counter.build()
          .name("service_request_source_count")
          .help("Number of requests received by source")
          .labelNames("source")
          .register();

  // 创建一个连接工厂，用于创建RabbitMQ连接
  private static final ConnectionFactory factory = new ConnectionFactory();
  static {
    factory.setHost("localhost");
  }

  // 定义一个切点，匹配所有被@Monitor注解标记的方法
  @Pointcut("@annotation(com.example.Monitor)")
  public void monitor() {}

  // 在方法调用前记录服务调用次数和调用来源
  @Before("monitor()")
  public void before(JoinPoint joinPoint) {
    requestCount.inc();
    String source = getSource(joinPoint);
    requestSource.labels(source).inc();
    sendToMQ(source, "before");
  }

  // 在方法调用后记录服务调用次数和调用来源，并将数据发送到RabbitMQ
  @After("monitor()")
  public void after(JoinPoint joinPoint) {
    requestCount.inc();
    String source = getSource(joinPoint);
    requestSource.labels(source).inc();
    sendToMQ(source, "after");
  }

  // 获取调用来源
  private String getSource(JoinPoint joinPoint) {
    Object[] args = joinPoint.getArgs();
    if (args != null && args.length > 0) {
      return args[0].toString();
    }
    return "";
  }

  // 将数据发送到RabbitMQ
  private void sendToMQ(String source, String stage) {
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {
      channel.queueDeclare("monitor", false, false, false, null);
      Map<String, String> data = new HashMap<>();
      data.put("source", source);
      data.put("stage", stage);
      channel.basicPublish("", "monitor", null, data.toString().getBytes());
    } catch (IOException | TimeoutException e) {
      e.printStackTrace();
    }
  }

  public static void main(String[] args) throws IOException {
    // 启动一个HTTP服务器，用于接收请求
    HTTPServer server = new HTTPServer(8080);
    System.out.println("Server started");

    // 注册Servlet
    server.getContext("/").addServlet(MyServlet.class, "/");

    // 启动一个RabbitMQ消费者，用于消费数据并插入数据库
    MQConsumer consumer = new MQConsumer();
    consumer.start();
  }
}

这个代码定义了一个自定义注解`@Monitor`，并使用切面`MonitorAspect`在方法调用前后记录服务调用次数和调用来源，并将数据发送到RabbitMQ。在发送数据到MQ时，我们使用了一个简单的JSON格式来表示数据，包括调用来源和调用阶段。最后，我们启动了一个HTTP服务器和一个RabbitMQ消费者，用于接收请求和消费数据并插入数据库。