Rabbitmq消息队列详解（二）——消息模式API

news2025/1/10 10:18:26

官网提供的消息模式：

在这里插入图片描述

依赖：

<!-- 加入rabbitmq -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

hello模型

在这里插入图片描述

没有交换机，直接传消息到队列

provider

    /**
     * hello模型
     * 不需要交换机直接把消息发布到队列
     * @throws IOException
     * @throws TimeoutException
     */
    @Test
    public void SendMessage() throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //同心绑定对应的消息队列
        //参数1，队列名称，如果队列不存在自动创建
        //参数2，用来定义队列是否需要持久化，true则持久化，rabbitmq关闭后重启还存在
        //参数3，是否独占队列，true则其他信道或者客户端无法连接该队列
        //参数4，是否在消费完成后自动删除队列
        //参数5，其他额外的参数，map
        channel.queueDeclare("hello", true,false,false,null);

        //发布消息
        //参数1，交换机名称，这里不需要
        //参数2，路由key，一般跟对应队列名称一致
        //参数3，传递消息额外设置，这里是设置消息持久化
        //参数4，消息内容，需要字节数组
        channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello rabbitmq".getBytes());

        channel.close();
        connection.close();
    }

customer

    @Test
    public void customerMessage() throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道绑定对应的消息队列
        //参数1，队列名称，如果队列不存在自动创建
        //参数2，用来定义队列是否需要持久化，true则持久化，rabbitmq关闭还存在
        //参数3，是否独占队列，true则其他信道或者客户端无法连接该队列
        //参数4，是否在消费完成后自动删除队列
        //参数5，其他额外的参数，map
        channel.queueDeclare("hello", true,false,false,null);

        //消费消息
        //参数1，队列名称
        //参数2，开始消息的自动确认机制
        //参数3，消息时的回调接口
        //参数4，消息内容，需要字节数组
        channel.basicConsume("hello",true,new DefaultConsumer(channel){

            @Override //最后一个参数，消息队列中取出的数据
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收的消息：" + new String(body));
            }
        });

        //一直监听
//        channel.close();
//        connection.close();
    }

任务模型

在这里插入图片描述

Work queues，任务/工作模型。当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。消息会堆积越来越多，无法及时处理，此时可以使用work模型：让多个消费者绑定到一个队列，共同消费队列中的消息。队列中的消息一旦消费，就会消息，不会重复执行。

队列平均分配，循环分配给消费者

provider

    /**
     * 任务模型
     * 多消费者消费
     * @throws IOException
     * @throws TimeoutException
     */
    @Test
    public void SendWordMessage() throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道绑定对应的消息队列
        //参数1，队列名称，如果队列不存在自动创建
        //参数2，用来定义队列是否需要持久化，true则持久化，rabbitmq关闭后重启还存在
        //参数3，是否独占队列，true则其他信道或者客户端无法连接该队列
        //参数4，是否在消费完成后自动删除队列
        //参数5，其他额外的参数，map
        channel.queueDeclare("work", true,false,false,null);

        //发布消息
        //参数1，交换机名称，这里不需要
        //参数2，路由key，一般跟对应队列名称一致
        //参数3，传递消息额外设置，这里是设置消息持久化
        //参数4，消息内容，需要字节数组
        for (int i = 0; i < 100; i++) {
            channel.basicPublish("","work", MessageProperties.PERSISTENT_TEXT_PLAIN,(i+": hello work").getBytes());
        }

        channel.close();
        connection.close();
    }

多个Customer

public class CustomerWork {

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //同心绑定对应的消息队列
        //参数1，队列名称，如果队列不存在自动创建
        //参数2，用来定义队列是否需要持久化，true则持久化，rabbitmq关闭还存在
        //参数3，是否独占队列，true则其他信道或者客户端无法连接该队列
        //参数4，是否在消费完成后自动删除队列
        //参数5，其他额外的参数，map
        channel.queueDeclare("work", true,false,false,null);

        //能者多劳，通道每一次只接收一个，而不是平均分配
        channel.basicQos(1);

        //消费消息
        //参数1，队列名称
        //参数2，开始消息的自动确认机制：队列分配消息给消费者后，自动确定删除，消费者可以拿到消息，但是可能没消费完
        //参数3，消息时的回调接口
        //参数4，消息内容，需要字节数组
        channel.basicConsume("work",false,new DefaultConsumer(channel){

            @Override //最后一个参数，消息队列中取出的数据
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(10000); //10秒
                    //任务模型，是平均分配给消费者，这里测试下消费者快慢下的分配情况
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("接收的消息：" + new String(body));
                //参数1：确认队列中具体消息，队列确认完删除，确认机制
                //参数2：是否开启多个消息同时确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });

        //一直监听
//        channel.close();
//        connection.close();
    }
}

public class CustomerWork2 {

    public static void main(String[] args) throws IOException, TimeoutException {

        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //同心绑定对应的消息队列
        //参数1，队列名称，如果队列不存在自动创建
        //参数2，用来定义队列是否需要持久化，true则持久化，rabbitmq关闭还存在
        //参数3，是否独占队列，true则其他信道或者客户端无法连接该队列
        //参数4，是否在消费完成后自动删除队列
        //参数5，其他额外的参数，map
        channel.queueDeclare("work", true,false,false,null);

        //能者多劳，通道每一次只接收一个，而不是平均分配
        channel.basicQos(1);

        //消费消息
        //参数1，队列名称
        //参数2，开始消息的自动确认机制：队列分配消息给消费者后，自动确定删除，消费者可以拿到消息，但是可能没消费完
        //参数3，消息时的回调接口
        //参数4，消息内容，需要字节数组
        channel.basicConsume("work",false, new DefaultConsumer(channel){

            @Override //最后一个参数，消息队列中取出的数据
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收的消息：" + new String(body));
                //参数1：确认队列中具体消息，队列确认完删除，确认机制
                //参数2：是否开启多个消息同时确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });

        //一直监听
//        channel.close();
//        connection.close();
    }

}

平均分配：消费者执行的消息都一样多，自动确认，但是如果某个消费者执行慢，分配还是一样多，处理不均。

能者多劳：每次分配一个，每次确认一个。

fanout模型

在这里插入图片描述

fanout又称广播。消息通过交换机分配到绑定的所有的队列中。

  • 可以有多个消费者
  • 每个消费者都有自己的队列
  • 每个队列都要绑定到交换机
  • 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
  • 交换机把消息发送给绑定过的所有队列
  • 队列的消息者都能拿到消息，实现一条消息被多个消费者消费

Provider

/**
 * fanout模型
 * 消息通过交换机分配到绑定的所有的队列中
 */
public class Provider {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("order","fanout");

        //发送消息
        //参数1：交换机名称
        //参数2：路由key，fanout模式不需要
        //参数3：额外参数
        //参数4：消息字节数组
        channel.basicPublish("order","",null,"fanout message".getBytes());

        channel.close();
        connection.close();
    }
}

可多个Customer，一个消息每一个Customer都会接收到消息，可用于分发消息给相同功能处理的不同系统。

public class Customer {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("order","fanout");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        //参数1：队列名字
        //参数2：交换机名称
        //参数3：路由key，fanout模式不需要
        channel.queueBind(queueName,"order","");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收消息：" + new String(body));
            }
        });
    }

}

direct模型

在这里插入图片描述

在fanout模型中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费，这时需要用到direct类型的exchange。生产者向交换机发送消息，发送消息时会指定一个RoutingKey，交换机根据消息的RoutingKey和队列的RoutingKey，把消息发送到对应的队列。

Direct模型:

  • 队列与交换机的绑定，不能任意绑定，而是指定一个RoutingKey(路由key)
  • 消息的发送方在向exchange发送消息时，也必须指定消息的RoutingKey
  • exchange根据RoutingKey进行判断，只有队列的RoutingKey与消息的RoutingKey完全一致，队列才能接收到消息。

Provider

/**
 * Title：direct模型
 * Description：根据路由key接收消息
 * @author WZQ
 * @version 1.0.0
 * @date 2020/3/29
 */
public class Provider {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("logs.direct","direct");

        //发送消息
        //参数1：交换机名称
        //参数2：路由key，fanout模式不需要
        //参数3：额外参数
        //参数4：消息字节数组
        channel.basicPublish("logs.direct","direct.error",null,"direct error message".getBytes());
        channel.basicPublish("logs.direct","direct.info",null,"direct info message".getBytes());


        channel.close();
        connection.close();
    }
}

Customer1：只接收对应路由key的消息

public class Customer {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("logs.direct","direct");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        //参数1：队列名字
        //参数2：交换机名称
        //参数3：路由key
        channel.queueBind(queueName,"logs.direct","direct.error");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收消息：" + new String(body));
            }
        });
    }

}

Customer2：只接收对应路由key的消息，key可以绑定多个。

public class Customer2 {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("logs.direct","direct");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        //参数1：队列名字
        //参数2：交换机名称
        //参数3：路由key
        channel.queueBind(queueName,"logs.direct","direct.test");
        channel.queueBind(queueName,"logs.direct","direct.warning");
        channel.queueBind(queueName,"logs.direct","direct.info");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收消息：" + new String(body));
            }
        });
    }

}

topic模型

在这里插入图片描述

相对于Direct模型，topics模型的exchange可以让队列在绑定RoutingKey的时候使用通配符，这种RoutingKey一般都是由一个或多个单词组成，多个单词直接以“.”分割。

*指匹配单个，#指匹配所有。例如：

user.#指user开头都可以匹配到

user.*指user+一个字段的可以匹配到

*.user指一个字段+user的可以匹配到

*.*.user指两个字段+user的可以匹配到

Provider

/**
 * Title：topic模型
 * Description：符号范围匹配路由消息
 * @author WZQ
 * @version 1.0.0
 * @date 2020/3/29
 */
public class Provider {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("logs.topics","topic");

        //发送消息
        //参数1：交换机名称
        //参数2：路由key，fanout模式不需要
        //参数3：额外参数
        //参数4：消息字节数组
        channel.basicPublish("logs.topics","user.save",null,"topics.user.save".getBytes());
        channel.basicPublish("logs.topics","user.select.test",null,"topics.user.select.test".getBytes());

        channel.close();
        connection.close();
    }
}

Customer1：只接收到user.save

public class Customer {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("logs.topics","topic");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        //参数1：队列名字
        //参数2：交换机名称
        //参数3：路由key
        channel.queueBind(queueName,"logs.topics","user.*");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收消息：" + new String(body));
            }
        });
    }

}

Customer2：接收到所有

public class Customer2 {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的属性，主机，账号，密码，端口，虚拟主机
        connectionFactory.setHost("192.168.169.135");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("wzq.host");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("123456");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的信道
        Channel channel = connection.createChannel();

        //信道声明指定的交换机
        //参数1：交换机名称
        //参数2：交换机类型（fanout、direct、topic）
        //rabbitmq中没有的话自动创建
        channel.exchangeDeclare("logs.topics","topic");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        //参数1：队列名字
        //参数2：交换机名称
        //参数3：路由key
        channel.queueBind(queueName,"logs.topics","user.#");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收消息：" + new String(body));
            }
        });
    }

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/146466.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

电商物流第三方云仓到底是什么？

电商物流第三方云仓到底是什么？

仓库能够简单地定义为一个规划空间&#xff0c;通常是一个用于处置和贮存货物的大型商业建筑。因而&#xff0c;仓储是指在这样一个规划空间中存储和处置货物所触及的一切过程。仓库中常见的货物包括&#xff1a;;机械零配件、建筑资料、废品农产品、家具和电子产品。仓库中的一…
阅读更多...
Git、GitHub、Gitee、GitLab

Git、GitHub、Gitee、GitLab

Git、GitHub、Gitee、GitLab 文章目录前言一、Git1.1 Git概述1.2 版本控制1.3 为什么需要版本控制1.4 版本控制工具1.5 Git简史1.6 Git工作机制1.7 Git和代码托管中心二、Git安装三、 Git常用命令3.1 设置用户签名3.2 初始化本地库3.3 查看本地库状态3.3.1 首次查看&#xff08…
阅读更多...
【c++】 仿函数的概念详解与基础实现

【c++】 仿函数的概念详解与基础实现

四、仿函数 函数对象(仿函数)是一个类&#xff0c;不是一个函数。 函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。分类:假定某个类有一个重载的operator()&#xff0c;而且重载的operator()要求获取一个参数&#xff0c;我们就将这个类称为“一元仿函数”&…
阅读更多...
【算法笔记】最近公共祖先（LCA）算法求解——倍增算法

【算法笔记】最近公共祖先（LCA）算法求解——倍增算法

0. 前言 最近公共祖先简称 LCA&#xff08;Lowest Common Ancestor&#xff09;。两个节点的最近公共祖先&#xff0c;就是这两个点的公共祖先里面&#xff0c;离根最远的那个。 这种算法应用很广泛&#xff0c;可以很容易解决树上最短路等问题。 为了方便&#xff0c;我们记…
阅读更多...
再获认可！知道创宇入选《2022中国各地区科创之星势力图3.0版》

再获认可！知道创宇入选《2022中国各地区科创之星势力图3.0版》

近日&#xff0c;由数据智能产业创新服务领域的垂直、专业深度媒体数据猿推出的《2022中国各地区科创之星势力图3.0版》正式公布。知道创宇凭借网络安全领域过硬的技术实力与创新能力入选“科创之星势力图”。二度认可知道创宇再获科创之星优秀企业本次数据猿公布的《2022中国各…
阅读更多...
第十九章AJAX学习

第十九章AJAX学习

文章目录什么是AJAX服务器端渲染Ajax渲染&#xff08;局部更新&#xff09;前后端分离同步与异步同步异步前端提交到数据到后端的方式JSON什么是JSONJSON数据格式JSON对象JSON格式表示简单数组对象数组使用二维数组保存对于客户端对于服务器端引入GSON的jar包使用例子Axios简介…
阅读更多...
MySQL数据库：库和表的基本操作

MySQL数据库：库和表的基本操作

SQL注意事项 1.每条sql语句都要以英文分号结尾。 2.sql语句不区分大小写。 3.定义库、表&#xff0c;或是表中的字段&#xff0c;名称不要使用关键字。 一、数据库的操作 1.显示所有的数据库 show databases; 2.创建数据库 方式一&#xff1a; create database 数据库名称…
阅读更多...
vue+elementui导入Excel文件（基于vue-element-admin中的uploadExcel组件), 然后 go-zero进行逻辑处理功能

vue+elementui导入Excel文件（基于vue-element-admin中的uploadExcel组件), 然后 go-zero进行逻辑处理功能

#前端代码 html代码 <el-button v-waves class"filter-item" type"primary" icon"add" click"downLoadExlce">模板下载</el-button> <el-upload class"upload" action :multiple"false" :show-…
阅读更多...
2.两数相加（链表）

2.两数相加（链表）

题目 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会…
阅读更多...
【Linux】动静态库的制作和使用

【Linux】动静态库的制作和使用

目录 一、可执行文件的形成 二、静态库 2.1 制作静态库 2.2 使用静态库 三、动态库 3.1 动态库的制作 3.2 动态库链接 2.3 动态库的加载 一、可执行文件的形成 在C语言中&#xff0c;函数库文件分为两种类型&#xff1a; 静态库&#xff08;库程序是直接注入目标程序…
阅读更多...
想要做成一件事，就得有方法，怎么做到呢

想要做成一件事，就得有方法，怎么做到呢

想要完成一件事&#xff0c;没有详细的计划和方法是做不好的。如果没有计划&#xff0c;没有方案&#xff0c;没有策略&#xff0c;没有规划&#xff0c;没有方法&#xff0c;那就是一只无头苍蝇&#xff0c;到处乱撞&#xff0c;不能达到什么目的。想做成一件事&#xff0c;就…
阅读更多...
后端人眼中的Vue（二）

后端人眼中的Vue（二）

三、Vue基本语法 3.1、展示数据 3.1.1、v-text 3.1.1.1、简介 ​ 和插值表达式&#xff08;{{}}&#xff09;一样&#xff0c;用于获取vue实例中data属性声明的数据。用法是在哪个标签上获取就直接在哪个标签上定义v-text或者是v-html。相当于javascript中的innerText。直接…
阅读更多...
笔记：Android 系统架构

笔记：Android 系统架构

Android系统架构 1.应用层&#xff08;System Apps&#xff09; 系统内置应用程序和非系统应用程序&#xff0c;源码目录中的 packages 目录对应系统应用层 2.应用架构层&#xff08;Framework&#xff09; 为开发人员提供应用程序开发所需要的API&#xff0c;向下与c/c程序…
阅读更多...
J-Tech Talk｜跨模态视频检索进阶，一起探索CLIP模型的新天地！

J-Tech Talk｜跨模态视频检索进阶，一起探索CLIP模型的新天地！

J-Tech Talk由 Jina AI 社区为大家带来的技术分享围绕 Python 的相关话题工程师们将深入细节地讲解具体的问题分享 Jina AI 在开发过程中所积累的经验CLIP 模型在零样本图像分类、跨模态检索中效果拔群&#xff0c;它的出现同时推动了 NLP 和 CV 的发展&#xff0c;为解决许多实…
阅读更多...
【自学C++】C++转义字符

【自学C++】C++转义字符

C转义字符 C转义字符教程 在编程中有一些字符是打不出来的&#xff0c;比如换行&#xff0c;提示音&#xff0c;下一个制表位等等&#xff0c;于是程序语言的开发者就设计了转义序列&#xff08;escape sequence&#xff09;这种东西用来表达这些字符。 所谓转义&#xff0c…
阅读更多...
jvm学习的核心（二）---运行时数据区概述

jvm学习的核心（二）---运行时数据区概述

文章目录1.方法区&#xff08; Method Area&#xff09;2.堆&#xff08;Heap&#xff09;3.本地方法栈&#xff08;Native Method Stacks&#xff09;4.程序计数器&#xff08;pc Register&#xff09;5.虚拟机栈&#xff08;Virtual Machine Stacks&#xff09;运行时数据区 …
阅读更多...
IDEA启动项目通过https进行访问，nginx配置https访问

IDEA启动项目通过https进行访问，nginx配置https访问

一、IDEA启动项目通过https进行访问 1、获取证书 证书申请网络有很多方法&#xff0c;这里腾讯云的nginx版证书举列 2、证书转换 springboot是识别p12证书的&#xff0c;所有这里需要吧pem证书进行转换。转换工具OpenSSL-Win64&#xff08;自行百度下载&#xff09;下载完…
阅读更多...
nodejs操作MySQL数据库

nodejs操作MySQL数据库

1、操作数据库的步骤 安装操作 MySQL 数据库的第三方模块&#xff08;mysql&#xff09;通过 mysql 模块连接到 MySQL 数据库通过 mysql 模块执行 SQL 语句2、安装与配置 mysql 模块 2.1、安装 mysql 模块 mysql 模块是托管于 npm 上的第三方模块。它提供了在 Node.js 项目中…
阅读更多...
【Centos】服务管理、解/压缩、磁盘、进程管理相关命令

【Centos】服务管理、解/压缩、磁盘、进程管理相关命令

文章目录一、服务管理1 service2 chkconfig设置后台服务器的自启配置3 systemctl设置后台服务器自启配置防火墙关闭4 开关机重启5 搜索查找类6 locate快速定位文件路径二、压缩、解压1 gzip2 zip3 tar三、磁盘查看和分区类1 du2 df3 lsblk4 mount5 fdisk四、进程管理类1 iotop2…
阅读更多...
Vue基础入门小demo——图片切换（初阶）

Vue基础入门小demo——图片切换（初阶）

文章目录 &#x1f4cb;前言 &#x1f3af;demo介绍 &#x1f3af;完整代码 &#x1f3af;最终效果 &#x1f3af;案例解析 &#x1f4cb;前言 图片切换是一个很经典的Vue入门学习案例&#xff0c;在你学习完一些基本的v-指令后&#xff0c;你可以尝试去写一个简单的demo去…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023