RabbitMQ简介

RabbitMQ简介   官网也讲述的清楚而且还有例子,只不过是英文的,很多人看到英文就不明白说什么了吧,即使有翻译成中文,总觉得哪里怪怪的,有些翻译并不流畅。我还是支持多看官网,官网:ht...

RabbitMQ简介

  官网也讲述的清楚而且还有例子,只不过是英文的,很多人看到英文就不明白说什么了吧,即使有翻译成中文,总觉得哪里怪怪的,有些翻译并不流畅。我还是支持多看官网,官网:https://www.rabbitmq.com/ 。下面是自己做的一点下笔记,有参考其他文档。如有什么不对的地方,希望大家能够告诉我,通过留言板,像消息队列一样,你发送消息,我接收消息。

一、消息队列(MQ)

  • 什么是消息队列:即MQ,Message Queue。是一种应用程序对应用对应用程序的通信方式。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信,而无需专用连接来连接他们。消息队列是典型的:生产者、消费者模型。生产者不断向消息队列中生产消息,消费者不断从队列中获取消息。【因为消息的生产和消费都是异步的,而且只关心消息的发送和接收,没有业务逻辑的侵入,这样就实现了生产者和消费者的解耦
  • AMQP和JMS
    • AMQP:即Advanced Message Queuing Protocol,一个提供统一消息服务的应用层标准(高级消息队列协议)。【限定了数据传输的格式和方式,跨语言跨平台,和http协议类似】。是应用层协议的一个开放标准,为面向消息的中间件设计。
    • JMS:Java MessageService,实际上指JMS API。JMS是SUN公司早期提出的消息标准,旨在为Java应用提供统一的消息操作,包括create、send、recieve等。JMS已经成为java Enterprise Edition的一部分。
    • 两者间的区别和联系:
      • JMS是定义了统一的接口,来对消息操作进行统一;AMQP是通过规定协议来统一数据交互的格式。
      • JMS限定了必须使用Java语言;AMQP只是协议,不规定实现方式,因此是跨语言的。
      • JMS规定了两种消息模型;而AMQP的消息模型更加丰富。
  • 常见MQ产品:
    • ActiveMQ:基于JMS, Apache旗下的
    • RabbitMQ:基于AMQP协议,erlang(一种通用的面向并发的编程语言)语言开发,稳定性好
    • RocketMQ:基于JMS,阿里巴巴产品,目前交由Apache基金会
    • Kafka:分布式消息系统,高吞吐量

二、RabbitMQ:

  • 下载安装:先安装erlang,在安装rabbitmq。(这里不详细说明,如果有不是很清楚的,可以去搜索,相信很多伙伴已经分享过很多这样的博客啦)
  • 启动步骤【window系统下的cmd命令行】:cd RabbitMQ Serverrabbitmq_server-3.7.15sbin(进入到你安装的rabbitmq目录的sbin目录) --> rabbitmq-plugins enable rabbitmq_management --> rabbitmq-server
  • 五种消息模型:RabbitMQ提供了6中消息模型,但是第6种RPC,并不是MQ。其中3/4/5这三种属于订阅模式,只不过进行路由的方式不同。
    • 基本消息模型:RabbitMQ是一个消息的代理者(Message broker):它接收消息并且传递消息。你可以认为它是一个邮局,当你投递邮件到一个邮箱,你很肯定邮递员终究会将邮件递交给你的收件人。与此类似,RabbitMQ可以是一个邮箱、邮局、同时还是邮递员。不同之处在于:RabbitMQ不是传递纸质邮件,而是二进制的数据。
      •   问题:那么RabbitMQ怎么知道消息被接收了呢?(转换思维,即如何避免消息的丢失?)【答:消费者的消息确认机制Acknowlege,当消费者获取消息后,会向RabbitMQ发送回执ACK,告知消息已经被接收。不过这种回执ACK分两种情况:① 自动ACK:消息一旦被接收,消费者自动发送ACK;② 手动ACK:消息接收后,不会发送ACK,需要手动调用。很好理解,望名知意嘛,嘿嘿嘿!!!】。
      • public class ConnectionUtil {
        
            /**
             * 建立与RabbitMQ的链接
             */
            public static Connection getConnection() throws IOException, TimeoutException {
                // 定义连接工厂
                ConnectionFactory factory = new ConnectionFactory();
                // 设置服务地址
                factory.setHost("127.0.0.1");
                // 端口
                factory.setPort(5672);
                // 设置账号信息,用户名、密码、vhost
                factory.setVirtualHost("/demo");
                factory.setUsername("guest");
                factory.setPassword("guest");
                // 通过工厂获取连接
                Connection connection = factory.newConnection();
                return connection;
            }
        }
        public class Send {
        
            private final static String QUEUE_NAME = "simple_queue";
        
            public static void main(String[] args) throws IOException, TimeoutException {
                // 获取到连接
                Connection connection = ConnectionUtil.getConnection();
                // 从连接中创建通道,使用通道才能完成消息相关的操作
                Channel channel = connection.createChannel();
                // 声明(创建)队列
                channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                // 消息内容
                String message = "Hello word!";
                // 向指定的队列中发送消息
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        
                System.out.println(" [x] Sent '" + message + "'");
        
                // 关闭通道和连接
                channel.close();
                connection.close();
            }
        }
        public class Recv {
        
            private final static String QUEUE_NAME = "simple_queue";
        
            public static void main(String[] args) throws Exception {
                // 获取连接
                Connection connection = ConnectionUtil.getConnection();
                // 创建通道
                Channel channel = connection.createChannel();
                // 声明队列
                channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                // 定义队列的消费者
                DefaultConsumer consumer = new DefaultConsumer(channel) {
                    // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动被调用
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                               byte[] body) throws IOException {
                        // body 即消息体
                        String msg = new String(body);
                        System.out.println(" [x] received: " + msg + "!");
                    }
                };
                // 监听队列,第二个参数:是否自动进行消息确认
                channel.basicConsume(QUEUE_NAME, true, consumer);
            }
        }
        public class Recv2 {
        
            private final static String QUEUE_NAME = "simple_queue";
        
            public static void main(String[] args) throws Exception {
                // 获取连接
                Connection connection = ConnectionUtil.getConnection();
                // 创建通道
                Channel channel = connection.createChannel();
                // 声明队列
                channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                // 定义队列的消费者
                DefaultConsumer consumer = new DefaultConsumer(channel) {
                    // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动被调用
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                               byte[] body) throws IOException {
                        // body 即消息体
                        String msg = new String(body);
                        System.out.println(" [x] received: " + msg + "!");
                        // 手动进行ACK
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    }
                };
                // 监听队列,第二个参数false,手动进行ACK
                channel.basicConsume(QUEUE_NAME, false, consumer);
            }
        }
    • work消息模型:也称为Task queue任务模型。当消息处理比较耗时的时候,可能产生消息的速度会远远大于消息的消费速度。长此以往,消息就会堆积越来越多,无法及时处理。此时就可以使用该模型:让多个消费者绑定到一个队列,共同消费队列中的消息。队列中的消息一旦消费,就会消失,因此任务是不会被重复执行的。
      •   问题:又会存在疑惑,任务是如何分配的,可以和显示生活中任务的分配联想起来呦?【答案:①  默认是任务平分,一次分配完全(即公平分配);② channel.basicQos(int num); 设置每个消费者同时只能处理num条数据(即能者多劳,耗时小的多处理些,你懂滴)】。
      • public class Send {
        
            private final static String QUEUE_NAME = "task_work_queue";
        
            public static void main(String[] args) throws Exception {
                // 获取到连接
                Connection connection = ConnectionUtil.getConnection();
                // 从连接中创建通道,使用通道才能完成消息相关的操作
                final Channel channel = connection.createChannel();
                // 声明(创建)队列
                channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                // 循环发布任务
                for (int i=0; i<50; i++) {
                    // 消息内容
                    String message = "task ... " + i;
                    channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                    System.out.println(" [x] Sent '" + message + "'");
                    Thread.sleep(i * 2);
                }
                // 关闭通道和连接
                channel.close();
                connection.close();
            }
        }
        public class Recv {
        
            private final static String QUEUE_NAME = "task_work_queue";
        
            public static void main(String[] args) throws Exception {
                // 获取连接
                Connection connection = ConnectionUtil.getConnection();
                // 创建通道
                Channel channel = connection.createChannel();
                // 声明队列
                channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                // 设置每个消费同时只能处理一条消息
                channel.basicQos(1);
                // 定义队列的消费者
                DefaultConsumer consumer = new DefaultConsumer(channel) {
                    // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动被调用
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                               byte[] body) throws IOException {
                        // body 即消息体
                        String msg = new String(body);
                        System.out.println(" [x] received: " + msg + "!");
        
                        try {
                            // 模拟完成任务的耗时:1000ms
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    }
                };
                // 监听队列,第二个参数:是否自动进行消息确认
                channel.basicConsume(QUEUE_NAME, false, consumer);
            }
        }
        /*
        * 对比上个消费者:耗时小,完成任务多些
        */
        public class Recv2 {
        
            private final static String QUEUE_NAME = "task_work_queue";
        
            public static void main(String[] args) throws Exception {
                // 获取连接
                Connection connection = ConnectionUtil.getConnection();
                // 创建通道
                final Channel channel = connection.createChannel();
                // 声明队列
                channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                // 设置每个消费同时只能处理一条消息
                channel.basicQos(1);
                // 定义队列的消费者
                DefaultConsumer consumer = new DefaultConsumer(channel) {
                    // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动被调用
                    @Override
                    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                               byte[] body) throws IOException {
                        // body 即消息体
                        String msg = new String(body);
                        System.out.println(" [x] received: " + msg + "!");
                        // 手动进行ACK
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    }
                };
                // 监听队列,第二个参数false,手动进行ACK
                channel.basicConsume(QUEUE_NAME, false, consumer);
            }
        }
    • 订阅模型分类:
      • 订阅模型 - Fanout:广播。一条消息,会被所有订阅的队列消费。
        • public class Send {
          
              private final static String EXCHANGE_NAME = "fanout_exchange_test";
          
              public static void main(String[] args) throws Exception {
                  // 获取连接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明exchange,指定类型为fanout
                  channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
                  // 消息内容
                  String message = "Hello everyone";
                  // 发布消息到Exchange
                  channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
                  System.out.println(" [生产者] Sent '" + message + "'");
                  channel.close();
                  connection.close();
              }
          }
          public class Recv {
          
              private final static String QUEUE_NAME = "fanout_exchange_queue_1";
              private final static String EXCHANGE_NAME = "fanout_exchange_test";
          
              public static void main(String[] args) throws IOException, TimeoutException {
                  // 获取到链接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明队列
                  channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                  // 绑定队列到交换机
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
                  // 定义队列的消费者
                  DefaultConsumer consumer = new DefaultConsumer(channel) {
                      // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动调用
                      @Override
                      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                          String msg = new String(body);
                          System.out.println(" [消费者1] received: " + msg + "!");
                      }
                  };
                  // 监听队列,自动返回完成
                  channel.basicConsume(QUEUE_NAME, true, consumer);
              }
          }
          public class Recv2 {
          
              private final static String QUEUE_NAME = "fanout_exchange_queue_2";
              private final static String EXCHANGE_NAME = "fanout_exchange_test";
          
              public static void main(String[] args) throws IOException, TimeoutException {
                  // 获取到链接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明队列
                  channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                  // 绑定队列到交换机
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
                  // 定义队列的消费者
                  DefaultConsumer consumer = new DefaultConsumer(channel) {
                      @Override
                      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                          String msg = new String(body);
                          System.out.println(" [消费者2] received: " + msg + "!");
                      }
                  };
                  // 监听队列,自动返回完成
                  channel.basicConsume(QUEUE_NAME, true, consumer);
              }
          }
      • 订阅模型 - Direct:不同的消息被不同的队列消费。在Direct模型下:
        •   队列与交换机的绑定,不能是任意绑定,而是要指定至少一个 RoutingKey(路由key);
        •   消息的发送方向 Exchange 发送消息时,也必须指定消息的 RoutingKey;
        •   Exchange 不再把消息交给每一个绑定的队列,而是根据消息的 RoutingKey 进行判断,只有队列的RoutingKey与消息的RoutingKey完全一致,才会接收到消息。
        • public class Send {
          
              private final static String EXCHANGE_NAME = "direct_exchange_test";
          
              public static void main(String[] args) throws Exception {
                  // 获取连接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明exchange,指定类型为direct
                  channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
                  // 消息内容
                  String message = "商品增加了,id = 1002";
                  // 发布消息到Exchange,并且指定routing key为:delete,代表删除商品
                  channel.basicPublish(EXCHANGE_NAME, "insert", null, message.getBytes());
                  System.out.println(" [商品服务] Sent '" + message + "'");
                  channel.close();
                  connection.close();
              }
          }
          public class Recv {
          
              private final static String QUEUE_NAME = "direct_exchange_queue_1";
              private final static String EXCHANGE_NAME = "direct_exchange_test";
          
              public static void main(String[] args) throws IOException, TimeoutException {
                  // 获取到链接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明队列
                  channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                  // 绑定队列到交换机,同时指定需要订阅的routing key。假设此处需要update和delete消息
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");
                  // 定义队列的消费者
                  DefaultConsumer consumer = new DefaultConsumer(channel) {
                      // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动调用
                      @Override
                      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                          String msg = new String(body);
                          System.out.println(" [消费者1] received: " + msg + "!");
                      }
                  };
                  // 监听队列,自动返回完成
                  channel.basicConsume(QUEUE_NAME, true, consumer);
              }
          }
          public class Recv2 {
          
              private final static String QUEUE_NAME = "direct_exchange_queue_2";
              private final static String EXCHANGE_NAME = "direct_exchange_test";
          
              public static void main(String[] args) throws IOException, TimeoutException {
                  // 获取到链接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明队列
                  channel.queueDeclare(QUEUE_NAME, false, false, false, null);
                  // 绑定队列到交换机,同时指定需要订阅的routing key。假设此处需要update和delete消息
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "update");
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "delete");
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "insert");
                  // 定义队列的消费者
                  DefaultConsumer consumer = new DefaultConsumer(channel) {
                      // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动调用
                      @Override
                      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                          String msg = new String(body);
                          System.out.println(" [消费者2] received: " + msg + "!");
                      }
                  };
                  // 监听队列,自动返回完成
                  channel.basicConsume(QUEUE_NAME, true, consumer);
              }
          }
      • 订阅模型 - Topic:可以根据RoutingKey把消息路由到不同的队列,Topic类型Exchange可以让队列在绑定RoutingKey的时候使用通配符
        • RoutingKey 一般都是有一个或多个单词组成,多个单词之间以“ . ”分割,例:item.insert。
        • 通配符规则:
          • #:匹配一个或多个词
          • *:匹配不多不少恰好一个词
        • public class Send {
          
              private final static String EXCHANGE_NAME = "topic_durable_exchange_test";
          
              public static void main(String[] args) throws Exception {
                  // 获取连接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
          
                  // 开启生产者确认
          //        channel.confirmSelect();
          
                  // 声明exchange,指定类型为topic, 并且设置durable为true,持久化
                  channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC, true);
                  // 消息内容
                  String message = "商品新增了,id = 1002";
                  // 发布消息到Exchange,并且指定routing key,消息持久化
                  channel.basicPublish(EXCHANGE_NAME, "item.insert", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
                  System.out.println(" [商品服务] Sent '" + message + "'");
          
                  // 等待rabbitmq的确认消息,true为确认收到,false为发出有误
          //        channel.waitForConfirms();
          
                  channel.close();
                  connection.close();
              }
          }
          public class Recv {
          
              private final static String QUEUE_NAME = "topic_durable_exchange_queue_1";
              private final static String EXCHANGE_NAME = "topic_durable_exchange_test";
          
              public static void main(String[] args) throws IOException, TimeoutException {
                  // 获取到链接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明队列, 第二个参数:true代表声明为持久化
                  channel.queueDeclare(QUEUE_NAME, true, false, false, null);
                  // 绑定队列到交换机,同时指定需要订阅的routing key。假设此处需要update和delete消息
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.update");
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.delete");
                  // 定义队列的消费者
                  DefaultConsumer consumer = new DefaultConsumer(channel) {
                      // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动调用
                      @Override
                      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                          String msg = new String(body);
                          System.out.println(" [消费者1] received: " + msg + "!");
                      }
                  };
                  // 监听队列,自动返回完成
                  channel.basicConsume(QUEUE_NAME, true, consumer);
              }
          }
          public class Recv2 {
          
              private final static String QUEUE_NAME = "topic_durable_exchange_queue_2";
              private final static String EXCHANGE_NAME = "topic_durable_exchange_test";
          
              public static void main(String[] args) throws IOException, TimeoutException {
                  // 获取到链接
                  Connection connection = ConnectionUtil.getConnection();
                  // 获取通道
                  Channel channel = connection.createChannel();
                  // 声明队列
                  channel.queueDeclare(QUEUE_NAME, true, false, false, null);
                  // 绑定队列到交换机,同时指定需要订阅的routing key。假设此处需要update和delete消息
                  channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.*");
                  // 定义队列的消费者
                  DefaultConsumer consumer = new DefaultConsumer(channel) {
                      // 获取消息,并且处理,这个方法类似事件监听,如果有消息时,会自动调用
                      @Override
                      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                          String msg = new String(body);
                          System.out.println(" [消费者2] received: " + msg + "!");
                      }
                  };
                  // 监听队列,自动返回完成
                  channel.basicConsume(QUEUE_NAME, true, consumer);
              }
          }
  • 当然啦,国内这么hot的rabbitMQ自然也是有集成到了springboot中滴,开心。
    • maven坐标依赖:
      <parent>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-parent</artifactId>
              <version>2.0.4.RELEASE</version>
      </parent>
      
      <dependencies>
              <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-amqp</artifactId>
              </dependency>
      </dependencies>
    • application.yml:
      spring:
        rabbitmq:
          host: 127.0.0.1
          username: guest
          password: guest
          virtual-host: /demo 
    • @Component
      public class Listener {
      
          @RabbitListener(bindings = @QueueBinding(
                  value = @Queue(value = "spring.test.queue", durable = "true"),
                  exchange = @Exchange(
                          value = "spring.test.exchange",
                          type = ExchangeTypes.TOPIC),
                  key = {"#.#"}))
          public void listen(String msg) {
              System.out.println("接收到的消息: " + msg);
          }
      }
  • 持久化:要将消息持久化,前提是:队列、Exchange都持久化
    • 交换机持久化:channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC, true);  // 参数三:设置durable为true。
    • 队列持久化:channel.queueDeclare(QUEUE_NAME, true, false, false, null);  // 参数二:设置为true,表示设置队列持久化。
    • 消息持久化:channel.basicPublish(EXCHANGE_NAME, "item.insert", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
  • 解决消息丢失?
    • ACK(消费者确认,由消费者向mq发送,防止消息丢失于消费者)
    • 持久化(防止rabbitmq把消息丢失)
    • 生产者确认机制publisher confirm(由mq向生产者发送,有些mq包含,有些不包含,比如:activeMQ不包含该机制,rabbitmq包含该机制)
    • 发送消息前,将消息持久化到数据库,并记录消息状态(可靠消息服务)
  • 思考问题(这个问题就留给你们思考啦?冲啊):如何保证消息发送的重复性,如何保证接口的幂等性(同一接口被重复执行,其结果一致)?【提示:加标识 消息的重发要谨慎】
  • 发表于 2020-04-21 14:47
  • 阅读 ( 111 )
  • 分类:网络文章

条评论

请先 登录 后评论
不写代码的码农
小编

篇文章

作家榜 »

  1. 小编 文章
返回顶部
部分文章转自于网络,若有侵权请联系我们删除