精华内容
下载资源
问答
  • SpringMVC核心知识梳理

    2018-03-19 22:33:14
    SpringMVC核心知识梳理
    SpringMVC核心知识梳理,未完待续……
    
    展开全文
  • 文章目录五、核心知识梳理2.面对对象继承2.1 父类与子类2.2 在python中继承的一些特点3.面向对象之成员归属4.面向对象之类成员的静态字段与普通字段5.面向对象之成员访问总规则6.面向对象类成员之静态方法与类方法7....
  • 什么是消息中间件以及RabbitMQ核心知识梳理

    1. 消息中间件概述

    1.1 什么是消息中间件

    MQ(Message Queue),消息队列是应用程序之间的通信方法。发送方是生产者,接收方是消费者!

    • 为什么使用MQ
      1、异步提速
      将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。用户体验吞吐量
      2、应用解耦
      MQ相当于一个中介,生产方通过MQ与消费方交互,它将应用程序进行解耦合。 提升容错、提升可维护性。
      3、削峰填谷
      避免大流量卡死数据库。引入MQ中间件。高峰期产生的数据积压在MQ就叫做“削峰”,高峰期过后的一段时间内,慢慢消费完积压的消息,这就叫做“填谷”

    • 有什么缺点
      1、系统可用性降低 外部依赖多,你还得保证MQ高可用,维护MQ。
      2、系统复杂度提高保证没有重复消费,消息顺序性
      3、数据一致性问题 有成功有不成功,需要保证数据一致性

    1.2 消息队列产品

    市场上常见的消息队列有如下:

    • RabbitMQ:基于AMQP协议,erlang(二郎😄)语言开发,稳定性好(倒数第二 万级,嗷嗷快微秒级)
      - ActiveMQ:基于JMS,Apache (倒数第一,万级)
    • RocketMQ:基于JMS,阿里
    • Kafka:类似MQ的产品;分布式消息系统,高吞吐量
      在这里插入图片描述

    1.3 AMQP 和 JMS

    AMQP是一种协议,binary wire-level protocol(链接协议)。
    JMS即Java消息服务(JavaMessage Service)应用程序接口。

    • JMS定义了统一的接口;AMQP通过协议统一交互的格式
    • JMS限定使用Java语言;AMQP协议,跨语言。
    • JMS两种消息模式;AMQP消息模式更加丰富

    1.4 RabbitMQ

    RabbitMQ是由erlang语言开发,基于AMQP(Advanced Message Queue 高级消息队列协议)协议实现的消息队列。
    在这里插入图片描述
    RabbitMQ工作模式:
    1、简单模式 HelloWorld
    一个生产者、一个消费者,不需要设置交换机(使用默认的交换机)

    2、工作队列模式 Work Queue
    一个生产者、多个消费者(竞争关系),不需要设置交换机(使用默认的交换机)

    3、发布订阅模式 Publish/subscribe
    需要设置类型为fanout的交换机,并且交换机和队列进行绑定,当发送消息到交换机后,交换机会将消息发送到绑定的队列

    4、路由模式 Routing
    需要设置类型为direct的交换机,交换机和队列进行绑定,并且指定routing key,当发送消息到交换机后,交换机会根据routing key将消息发送到对应的队列

    5、通配符模式 Topic
    需要设置类型为topic的交换机,交换机和队列进行绑定,并且指定通配符方式的routing key,当发送消息到交换机后,交换机会根据routing key将消息发送到对应的队列

    2. 安装及配置RabbitMQ

    1,首先搞个服务器腾讯云、阿里云、华为云不嫌麻烦可以自己装虚拟机操作。
    2,服务器上的基础Linux配置。

    1. 安装依赖环境
      在线安装依赖环境:
    yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz
    
    1. 安装Erlang
      下载好3个安装包上传到服务器上的文件夹
      erlang-18.3-1.el7.centos.x86_64.rpm
      socat-1.7.3.2-5.el7.lux.x86_64.rpm
      rabbitmq-server-3.6.5-1.noarch.rpm
    # 安装
    rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm
    # 安装
    rpm -ivh socat-1.7.3.2-5.el7.lux.x86_64.rpm
    # 安装
    rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm
    
    1. 开启管理界面及配置
    # 开启管理界面
    rabbitmq-plugins enable rabbitmq_management
    # 修改默认配置信息
    vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app 
    # 比如修改密码、配置等等,例如:loopback_users 中的 <<"guest">>,只保留guest
    

    在这里插入图片描述
    在这里插入图片描述
    4. 启动

    service rabbitmq-server start # 启动服务
    service rabbitmq-server stop # 停止服务
    service rabbitmq-server restart # 重启服务
    

    3. RabbitMQ代码实战

    1,简单模式

    生产者代码

    package com.leo.producer;
    
    import com.leo.client.Channel;
    import com.leo.client.Connection;
    import com.leo.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /**
     * 发送消息
     */
    public class Producer_HelloWorld {
        public static void main(String[] args) throws IOException, TimeoutException {
    
            //1.创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2. 设置参数
            factory.setHost("42.192.XXX.24");//ip  默认值 localhost
            factory.setPort(5672); //端口  默认值 5672
            factory.setVirtualHost("/leo");//虚拟机 默认值/
            factory.setUsername("leo");//用户名 默认 guest
            factory.setPassword("leo");//密码 默认值 guest
            //3. 创建连接 Connection
            Connection connection = factory.newConnection();
            //4. 创建Channel
            Channel channel = connection.createChannel();
            //5. 创建队列Queue
            /*
            queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
            参数:
                1. queue:队列名称
                2. durable:是否持久化,当mq重启之后,还在
                3. exclusive:
                    * 是否独占。只能有一个消费者监听这队列
                    * 当Connection关闭时,是否删除队列
                4. autoDelete:是否自动删除。当没有Consumer时,自动删除掉
                5. arguments:参数。
             */
            //如果没有一个名字叫hello_world的队列,则会创建该队列,如果有则不会创建
            channel.queueDeclare("hello_world",true,false,false,null);
            /*
            basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
            参数:
                1. exchange:交换机名称。简单模式下交换机会使用默认的 ""
                2. routingKey:路由名称
                3. props:配置信息
                4. body:发送消息数据
             */
            String body = "你好,我的朋友!!!我是来自地球的Leo";
            //6. 发送消息
            channel.basicPublish("","hello_world",null,body.getBytes());
            //7.释放资源
          channel.close();
          connection.close();
        }
    }
    

    消费者代码

    package com.leo.consumer;
    import com.rabbitmq.client.*;
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_HelloWorld {
        public static void main(String[] args) throws IOException, TimeoutException {
    
            //1.创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2. 设置参数
            factory.setHost("42.192.XXX.24");//ip  默认值 localhost
            factory.setPort(5672); //端口  默认值 5672
            factory.setVirtualHost("/leo");//虚拟机 默认值/
            factory.setUsername("leo");//用户名 默认 guest
            factory.setPassword("leo");//密码 默认值 guest
            //3. 创建连接 Connection
            Connection connection = factory.newConnection();
            //4. 创建Channel
            Channel channel = connection.createChannel();
            //5. 创建队列Queue
            //如果没有一个名字叫hello_world的队列,则会创建该队列,如果有则不会创建
            channel.queueDeclare("hello_world",true,false,false,null);
            /*
            basicConsume(String queue, boolean autoAck, Consumer callback)
            参数:
                1. queue:队列名称
                2. autoAck:是否自动确认
                3. callback:回调对象
             */
            // 接收消息
            Consumer consumer = new DefaultConsumer(channel){
                /*
                    回调方法,当收到消息后,会自动执行该方法
                    1. consumerTag:标识
                    2. envelope:获取一些信息,交换机,路由key...
                    3. properties:配置信息
                    4. body:数据
                 */
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("consumerTag:"+consumerTag);
                    System.out.println("Exchange:"+envelope.getExchange());
                    System.out.println("RoutingKey:"+envelope.getRoutingKey());
                    System.out.println("properties:"+properties);
                    System.out.println("body:"+new String(body));
                }
            };
            channel.basicConsume("hello_world",true,consumer);
        }
    }
    
    

    2,Work Queues工作队列模式

    Work Queues与入门程序的简单模式的代码是几乎一样的
    生产者

    package com.leo.rabbitmq.work;
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    public class Producer {
        static final String QUEUE_NAME = "work_queue";
        public static void main(String[] args) throws Exception {
            //创建连接
            Connection connection = ConnectionUtil.getConnection();
            // 创建频道
            Channel channel = connection.createChannel();
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            for (int i = 1; i <= 30; i++) {
                // 发送信息
                String message = "你好;小兔子!work模式--" + i;
                /**
                 * 参数1:交换机名称,如果没有指定则使用默认Default Exchage
                 * 参数2:路由key,简单模式可以传递队列名称
                 * 参数3:消息其它属性
                 * 参数4:消息内容
                 */
                channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
                System.out.println("已发送消息:" + message);
            }
            // 关闭资源
            channel.close();
            connection.close();
        }
    }
    

    消费者1

    package com.leo.rabbitmq.work;
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    import java.io.IOException;
    public class Consumer1 {
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
            // 创建频道
            Channel channel = connection.createChannel();
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
            //一次只能接收并处理一个消息
            channel.basicQos(1);
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    try {
                        //路由key
                        System.out.println("路由key为:" + envelope.getRoutingKey());
                        //交换机
                        System.out.println("交换机为:" + envelope.getExchange());
                        //消息id
                        System.out.println("消息id为:" + envelope.getDeliveryTag());
                        //收到的消息
                        System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
                        Thread.sleep(1000);
                        //确认消息
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.QUEUE_NAME, false, consumer);
        }
    }
    

    消费者2

    package com.leo.rabbitmq.work;
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    import java.io.IOException;
    
    public class Consumer2 {
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
            // 创建频道
            Channel channel = connection.createChannel();
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
            //一次只能接收并处理一个消息
            channel.basicQos(1);
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    try {
                        //路由key
                        System.out.println("路由key为:" + envelope.getRoutingKey());
                        //交换机
                        System.out.println("交换机为:" + envelope.getExchange());
                        //消息id
                        System.out.println("消息id为:" + envelope.getDeliveryTag());
                        //收到的消息
                        System.out.println("消费者2-接收到的消息为:" + new String(body, "utf-8"));
                        Thread.sleep(1000);
    
                        //确认消息
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.QUEUE_NAME, false, consumer);
        }
    }
    
    

    在一个队列中如果有多个消费者,那么消费者之间对于同一个消息的关系是竞争的关系。

    3,Publish/Subscribe发布与订阅模式

    订阅模型中,多了一个exchange角色,而且过程略有变化:

    • P:生产者,也就是要发送消息的程序,但是不再发送到队列中,而是发给X(交换机)
    • C:消费者,消息的接受者,会一直等待消息到来。
    • Queue:消息队列,接收消息、缓存消息。
    • Exchange:交换机,图中的X。一方面,接收生产者发送的消息。另一方面,知道如何处理消息,例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作,取决于Exchange的类型。Exchange有常见以下3种类型:
      • Fanout:广播,将消息交给所有绑定到交换机的队列
      • Direct:定向,把消息交给符合指定routing key 的队列
      • Topic:通配符,把消息交给符合routing pattern(路由模式) 的队列
        Exchange(交换机)只负责转发消息,不具备存储消息的能力,因此如果没有任何队列与Exchange绑定,或者没有符合路由规则的队列,那么消息会丢失!

    发布订阅模式:
    1、每个消费者监听自己的队列。
    2、生产者将消息发给broker,由交换机将消息转发到绑定此交换机的每个队列,每个绑定交换机的队列都将接收
    到消息

    生产者

    package com.leo.rabbitmq.ps;
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    
    /**
     * 发布与订阅使用的交换机类型为:fanout
     */
    public class Producer {
        //交换机名称
        static final String FANOUT_EXCHAGE = "fanout_exchange";
        //队列名称
        static final String FANOUT_QUEUE_1 = "fanout_queue_1";
        //队列名称
        static final String FANOUT_QUEUE_2 = "fanout_queue_2";
    
        public static void main(String[] args) throws Exception {
            //创建连接
            Connection connection = ConnectionUtil.getConnection();
            // 创建频道
            Channel channel = connection.createChannel();
            /**
             * 声明交换机
             * 参数1:交换机名称
             * 参数2:交换机类型,fanout、topic、direct、headers
             */
            channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null);
            channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);
            //队列绑定交换机
            channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHAGE, "");
            channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHAGE, "");
    
            for (int i = 1; i <= 10; i++) {
                // 发送信息
                String message = "你好;小兔子!发布订阅模式--" + i;
                /**
                 * 参数1:交换机名称,如果没有指定则使用默认Default Exchage
                 * 参数2:路由key,简单模式可以传递队列名称
                 * 参数3:消息其它属性
                 * 参数4:消息内容
                 */
                channel.basicPublish(FANOUT_EXCHAGE, "", null, message.getBytes());
                System.out.println("已发送消息:" + message);
            }
    
            // 关闭资源
            channel.close();
            connection.close();
        }
    }
    

    消费者1

    package com.leo.rabbitmq.ps;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    import java.io.IOException;
    
    public class Consumer1 {
    
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
            // 创建频道
            Channel channel = connection.createChannel();
            //声明交换机
            channel.exchangeDeclare(Producer.FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);
            //队列绑定交换机
            channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHAGE, "");
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为:" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为:" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为:" + envelope.getDeliveryTag());
                    //收到的消息
                    System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.FANOUT_QUEUE_1, true, consumer);
        }
    }
    

    消费者2

    package com.leo.rabbitmq.ps;
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    import java.io.IOException;
    public class Consumer2 {
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
            // 创建频道
            Channel channel = connection.createChannel();
            //声明交换机
            channel.exchangeDeclare(Producer.FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.FANOUT_QUEUE_2, true, false, false, null);
            //队列绑定交换机
            channel.queueBind(Producer.FANOUT_QUEUE_2, Producer.FANOUT_EXCHAGE, "");
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为:" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为:" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为:" + envelope.getDeliveryTag());
                    //收到的消息
                    System.out.println("消费者2-接收到的消息为:" + new String(body, "utf-8"));
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.FANOUT_QUEUE_2, true, consumer);
        }
    }
    

    启动所有消费者,然后使用生产者发送消息;在每个消费者对应的控制台可以查看到生产者发送的所有消息;到达广播的效果。交换机需要与队列进行绑定,绑定之后;一个消息可以被多个消费者都收到。

    发布订阅模式与工作队列模式的区别

    1、工作队列模式不用定义交换机,而发布/订阅模式需要定义交换机。
    2、发布/订阅模式的生产方是面向交换机发送消息,工作队列模式的生产方是面向队列发送消息(底层用默认交换机)。
    3、发布/订阅模式需要设置队列和交换机的绑定,工作队列不需设置将队列绑定到默认的交换机 。

    4,Routing路由模式

    路由模式特点:

    • 队列与交换机的绑定,不能是任意绑定了,而是要指定一个RoutingKey(路由key)

    • 消息的发送方在 向 Exchange发送消息时,也必须指定消息的 RoutingKey

    • Exchange不再把消息交给每一个绑定的队列,而是根据消息的Routing Key进行判断,只有队列的Routingkey与消息的 Routing key完全一致,才会接收到消息

    • P:生产者,向Exchange发送消息,发送消息时,会指定一个routing key。

    • X:Exchange(交换机),接收生产者的消息,然后把消息递交给 与routing key完全匹配的队列

    • C1:消费者,其所在队列指定了需要routing key 为 error 的消息

    • C2:消费者,其所在队列指定了需要routing key 为 info、error、warning 的消息

    在编码上与 Publish/Subscribe发布与订阅模式 的区别是交换机的类型为:Direct,还有队列绑定交换机的时候需要指定routing key。

    生产者

    package com.leo.rabbitmq.routing;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    
    /**
     * 路由模式的交换机类型为:direct
     */
    public class Producer {
    
        //交换机名称
        static final String DIRECT_EXCHAGE = "direct_exchange";
        //队列名称
        static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
        //队列名称
        static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";
    
        public static void main(String[] args) throws Exception {
    
            //创建连接
            Connection connection = ConnectionUtil.getConnection();
    
            // 创建频道
            Channel channel = connection.createChannel();
    
            /**
             * 声明交换机
             * 参数1:交换机名称
             * 参数2:交换机类型,fanout、topic、direct、headers
             */
            channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
    
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
            channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);
    
            //队列绑定交换机
            channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHAGE, "insert");
            channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHAGE, "update");
    
            // 发送信息
            String message = "新增了商品。路由模式;routing key 为 insert " ;
            /**
             * 参数1:交换机名称,如果没有指定则使用默认Default Exchage
             * 参数2:路由key,简单模式可以传递队列名称
             * 参数3:消息其它属性
             * 参数4:消息内容
             */
            channel.basicPublish(DIRECT_EXCHAGE, "insert", null, message.getBytes());
            System.out.println("已发送消息:" + message);
    
            // 发送信息
            message = "修改了商品。路由模式;routing key 为 update" ;
            /**
             * 参数1:交换机名称,如果没有指定则使用默认Default Exchage
             * 参数2:路由key,简单模式可以传递队列名称
             * 参数3:消息其它属性
             * 参数4:消息内容
             */
            channel.basicPublish(DIRECT_EXCHAGE, "update", null, message.getBytes());
            System.out.println("已发送消息:" + message);
    
            // 关闭资源
            channel.close();
            connection.close();
        }
    }
    
    

    消费者1

    package com.leo.rabbitmq.routing;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    
    public class Consumer1 {
    
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
    
            // 创建频道
            Channel channel = connection.createChannel();
    
            //声明交换机
            channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
    
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);
    
            //队列绑定交换机
            channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHAGE, "insert");
    
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为:" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为:" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为:" + envelope.getDeliveryTag());
                    //收到的消息
                    System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, consumer);
        }
    }
    
    

    消费者2

    package com.leo.rabbitmq.routing;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    
    public class Consumer2 {
    
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
    
            // 创建频道
            Channel channel = connection.createChannel();
    
            //声明交换机
            channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
    
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.DIRECT_QUEUE_UPDATE, true, false, false, null);
    
            //队列绑定交换机
            channel.queueBind(Producer.DIRECT_QUEUE_UPDATE, Producer.DIRECT_EXCHAGE, "update");
    
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为:" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为:" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为:" + envelope.getDeliveryTag());
                    //收到的消息
                    System.out.println("消费者2-接收到的消息为:" + new String(body, "utf-8"));
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.DIRECT_QUEUE_UPDATE, true, consumer);
        }
    }
    
    

    启动所有消费者,然后使用生产者发送消息;在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息;到达按照需要接收的效果。
    Routing模式要求队列在绑定交换机时要指定routing key,消息会转发到符合routing key的队列。

    5,Topics通配符模式

    Topic类型与Direct相比,都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符
    Routingkey 一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: item.insert
    通配符规则:
    #:匹配一个或多个词
    *:匹配不多不少恰好1个词
    举例:
    item.#:能够匹配item.insert.abc 或者 item.insert
    item.*:只能匹配item.insert

    1)生产者
    使用topic类型的Exchange,发送消息的routing key有3种: item.insertitem.updateitem.delete

    package com.leo.rabbitmq.topic;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    
    /**
     * 通配符Topic的交换机类型为:topic
     */
    public class Producer {
    
        //交换机名称
        static final String TOPIC_EXCHAGE = "topic_exchange";
        //队列名称
        static final String TOPIC_QUEUE_1 = "topic_queue_1";
        //队列名称
        static final String TOPIC_QUEUE_2 = "topic_queue_2";
    
        public static void main(String[] args) throws Exception {
    
            //创建连接
            Connection connection = ConnectionUtil.getConnection();
    
            // 创建频道
            Channel channel = connection.createChannel();
    
            /**
             * 声明交换机
             * 参数1:交换机名称
             * 参数2:交换机类型,fanout、topic、topic、headers
             */
            channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
    
    
            // 发送信息
            String message = "新增了商品。Topic模式;routing key 为 item.insert " ;
            channel.basicPublish(TOPIC_EXCHAGE, "item.insert", null, message.getBytes());
            System.out.println("已发送消息:" + message);
    
            // 发送信息
            message = "修改了商品。Topic模式;routing key 为 item.update" ;
            channel.basicPublish(TOPIC_EXCHAGE, "item.update", null, message.getBytes());
            System.out.println("已发送消息:" + message);
    
            // 发送信息
            message = "删除了商品。Topic模式;routing key 为 item.delete" ;
            channel.basicPublish(TOPIC_EXCHAGE, "item.delete", null, message.getBytes());
            System.out.println("已发送消息:" + message);
    
            // 关闭资源
            channel.close();
            connection.close();
        }
    }
    
    

    2)消费者1

    接收两种类型的消息:更新商品和删除商品

    package com.leo.rabbitmq.topic;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    
    public class Consumer1 {
    
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
    
            // 创建频道
            Channel channel = connection.createChannel();
    
            //声明交换机
            channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
    
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.TOPIC_QUEUE_1, true, false, false, null);
    
            //队列绑定交换机
            channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHAGE, "item.update");
            channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHAGE, "item.delete");
    
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为:" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为:" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为:" + envelope.getDeliveryTag());
                    //收到的消息
                    System.out.println("消费者1-接收到的消息为:" + new String(body, "utf-8"));
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.TOPIC_QUEUE_1, true, consumer);
        }
    }
    
    

    ** 3)消费者2**

    接收所有类型的消息:新增商品,更新商品和删除商品。

    package com.leo.rabbitmq.topic;
    
    import com.leo.rabbitmq.util.ConnectionUtil;
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    
    public class Consumer2 {
    
        public static void main(String[] args) throws Exception {
            Connection connection = ConnectionUtil.getConnection();
    
            // 创建频道
            Channel channel = connection.createChannel();
    
            //声明交换机
            channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
    
            // 声明(创建)队列
            /**
             * 参数1:队列名称
             * 参数2:是否定义持久化队列
             * 参数3:是否独占本次连接
             * 参数4:是否在不使用的时候自动删除队列
             * 参数5:队列其它参数
             */
            channel.queueDeclare(Producer.TOPIC_QUEUE_2, true, false, false, null);
    
            //队列绑定交换机
            channel.queueBind(Producer.TOPIC_QUEUE_2, Producer.TOPIC_EXCHAGE, "item.*");
    
            //创建消费者;并设置消息处理
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                /**
                 * consumerTag 消息者标签,在channel.basicConsume时候可以指定
                 * envelope 消息包的内容,可从中获取消息id,消息routingkey,交换机,消息和重传标志(收到消息失败后是否需要重新发送)
                 * properties 属性信息
                 * body 消息
                 */
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    //路由key
                    System.out.println("路由key为:" + envelope.getRoutingKey());
                    //交换机
                    System.out.println("交换机为:" + envelope.getExchange());
                    //消息id
                    System.out.println("消息id为:" + envelope.getDeliveryTag());
                    //收到的消息
                    System.out.println("消费者2-接收到的消息为:" + new String(body, "utf-8"));
                }
            };
            //监听消息
            /**
             * 参数1:队列名称
             * 参数2:是否自动确认,设置为true为表示消息接收到自动向mq回复接收到了,mq接收到回复会删除消息,设置为false则需要手动确认
             * 参数3:消息接收到后回调
             */
            channel.basicConsume(Producer.TOPIC_QUEUE_2, true, consumer);
        }
    }
    

    启动所有消费者,然后使用生产者发送消息;在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息;到达按照需要接收的效果;并且这些routing key可以使用通配符。
    Topic主题模式可以实现 Publish/Subscribe发布与订阅模式Routing路由模式 的功能;只是Topic在配置routing key 的时候可以使用通配符,显得更加灵活。

    展开全文
  • 核心知识梳理之面对对象的self的理解和封装。

    五、核心知识梳理

    1.面向对象之self理解和封装

    1.1 例子
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    class test:
        def func_1(self,para_1):
            print (para_1,self)
    
    obj = test()
    obj01 = test()
    
    
    print (obj)
    print (obj.func_1('option'))
    print ('===================')
    print (obj01)
    print (obj01.func_1('option'))
    

    在这里插入图片描述

    • obj

    • obj01

    两个值相同

    self是一个形式参数,Python内部传递

    obj = test()
    obj.func_1('option')
    

    这个过程,将obj传递给self,将option传递给func_1

    1.2 为啥要对class进行实例化成一个对象

    具体的类

    class test:
     def func_1(self,para_1):
        print (para_1,self)
        return self.para_1
     def func_2(self,para_1):
        print (para_1,self)
     def func_3(self,para_1):
        print (para_1,self)
        
        
    obj = test()
    obj.para_1 = 'haha'
    print (obj.func_1())
    print (obj.func_2())
    print (obj.func_3())  
    

    在这里插入图片描述

    这种要重传参数

    obj = test()
    obj.para_1 = 'haha'
    obj.func_1('123')
    obj.func_2('456')
    obj.func_3('789')
    

    在这里插入图片描述

    而且para_1的赋值不能丢

    所以要对代码进行修改

    进行修改:

    class test:
     def func_1(self):
         print (self.para_1,self)
         return self.para_1
     def func_2(self):
         print (self.para_1,self)
         return self.para_1
     def func_3(self):
         print (self.para_1,self)
         return self.para_1
    obj = test()
    obj.para_1 = 'haha'
    print (obj.func_1())
    print (obj.func_2())
    print (obj.func_3())
    

    在这里插入图片描述

    内部结构图

    在这里插入图片描述

    将类test实例化成对象obj,然后在对象obj中定义一个变量对应的值:obj.para_1=‘haha’。

    方法中的self,就是指实例化的对象obj,通过self.para_1,就是调用obj这个对象中的para_1参数的值

    1.3 面对对象之常用封装方法
    class test:
        def __init__(self, a): # 使用__init__方法,进行变量初始化
            self.para_1 = 'liuyifei' # 初始化一个对象中的变量para_1,并赋值'liuyifei'
            self.para_2 = a # 初始化对象中的变量para_2并将实例化后的对象传递进来的参数赋值给para_2
    
        def func_1(self):
            return self.para_1, self.para_2
    
        def func_2(self):
            return self.para_1, self.para_2
    
        def func_3(self):
            return self.para_1, self.para_2
    
    obj = test('biubiubiu') # 实例化一个类,形成一个对象obj,并将值biubiubiu传递给__init__中的形参a
    print (obj.func_1())
    print (obj.func_2())
    print (obj.func_3())
    
    
    obj_temp = test('1111111')
    print (obj_temp.func_1())
    print (obj_temp.func_2())
    print (obj_temp.func_3())
    

    在这里插入图片描述

    这里a形参

    在这里插入图片描述

    展开全文
  • 核心知识梳理之面对对象成员修饰符,特殊成员call、setitem、getitem、delitem、dict、tier,以及面对对象的支柱。

    五、核心知识梳理

    9.面向对象之成员修饰符

    9.4 静态方法
    class test:
     def __init__(self,name):
        self.s_name = name
    
     @staticmethod
     def test_func(para):
        return para
    print (test.test_func('abc')) # 静态方法通过类进行访问
    

    在这里插入图片描述

    给test_func函数加上私有

    class test:
     def __init__(self,name):
        self.s_name = name
    
     @staticmethod
     def __test_func(para): # 加上私有下划线__
        return para
    print (test.test_func('abc')) 
    

    在这里插入图片描述

    用类中的其他方法调用私有函数

    class test:
     def __init__(self,name):
        self.s_name = name
    
     @staticmethod
     def __test_func(para):
        return para
    
     def test_func01(self):
         return test.__test_func(self.s_name)
    
    obj =test('abc')
    print (obj.test_func01())
    

    在这里插入图片描述

    9.5 普通方法

    私有函数

    class test:
     def __init__(self,name):
        self.s_name = name
    
    
     def __test_func(self):
        return self.s_name
    
    
    obj =test('abc')
    print (obj.__test_func())
    

    在这里插入图片描述

    用类中的方法调用私有函数

    class test:
     def __init__(self,name):
        self.s_name = name
    
    
     def __test_func(self):
        return self.s_name
    
     def test_func01(self):
         return self.__test_func()  # 返回用过私有修饰符修饰过的普通方法的返回值
    
    obj =test('abc')
    print (obj.test_func01())
    

    在这里插入图片描述

    总结:通过私有修饰符进行修饰后的成员,只能被自己访问

    10.面对对象之类的特殊成员call、setitem、getitem、delitem

    10.1 call
    class test:
     def __init__(self,name):
        self.s_name = name
    
     def func(self):
        print (self.s_name)
     
     def __call__(self):
        return 'call'
    
    obj = test('abc')
    print (obj) # obj是一个实例化后的对象
    print (obj()) # 直接是对象加上括号,这种执行方式,就是执行对象中的__call__方法
    

    在这里插入图片描述

    10.2 setitem、getitem、delitem
    • getitem
    class test:
     def __init__(self,name):
        self.s_name = name
    
     def func(self):
        print (self.s_name)
    
     def __getitem__(self, para):
        return para
    
    obj = test('abc')
    print (obj['get_item'])  
    # 通过对象名[para]的方式,是访问对象中的__getitem__方法
    

    在这里插入图片描述

    • setitem
    class test:
     def __init__(self,name):
        self.s_name = name
    
     def func(self):
        print (self.s_name)
    
     def __setitem__(self, key, value):
        print(key, value)
    
    
    obj = test('abc')
    obj['get_item']= '123' 
    # 通过对象名[key]=value的方式,是访问对象中的__setitem__方法,
    # 其中的set_item这个值传给__setitem__中的key,123传给__setitem__中的value
    

    在这里插入图片描述

    • delitem
    class test:
     def __init__(self,name):
        self.s_name = name
    
     def func(self):
        print (self.s_name)
    
     def __delitem__(self, key):
        print (key)
    
    obj = test('abc')
    del obj['get_item']
    # 通过del 对象名[key]的方式访问对象中的__delitem__方法,其中的get_item这个值传给了__delitem__中的key
    

    在这里插入图片描述

    总结

    obj[‘get_item’] #getitem

    obj[‘get_item’] = ‘123’ #setitem

    del obj[‘get_item’] #delitem

    11.面向对象之类的特殊成员dict

    class test:
     def __init__(self,name):
        self.s_name = name
    
     def func(self):
         print (self.s_name)
    
     def __delitem__(self,key):
         print (key)
    
    obj = test('abc')
    print (test.__dict__) # 输出类test中的__dict__
    print (obj.__dict__) # 输出对象obj中的__dict__
    

    输出结果

    {'__module__': '__main__', '__init__': <function test.__init__ at 0x0000022236E08708>, 'func': <function test.func at 0x0000022236E08DC8>, '__delitem__': <function test.__delitem__ at 0x0000022236E08948>, '__dict__': <attribute '__dict__' of 'test' objects>, '__weakref__': <attribute '__weakref__' of 'test' objects>, '__doc__': None}
    
    
    {'s_name': 'abc'}
    

    在这里插入图片描述

    12.面向对象之类的特殊成员tier

    import time
    class test:
     def __init__(self):
         pass
     def __iter__(self):
        yield 1
        time.sleep(3)
        yield 2
        time.sleep(3)
        yield 3
    obj = test()
    for i in obj: # for循环对象obj
     print (str(i) + ' number')
    

    在这里插入图片描述

    如果对对象执行for循环即为循环对象时会自动执行对象中的iter方法,生成器返回值

    六、面向对象的支柱

    面向对象有三大支柱:封装、继承和多态。

    封装:隐藏一切可以隐藏的实现细节,只向外界暴露(提供)简单的编程接口

    封装的例子:

    类中定义的方法:把数据和数据的操作封装起来

    展开全文
  • Mybatis核心知识梳理

    2021-06-02 17:04:29
    2.2主要构件及其相互关系 构建 描述 SqlSession 作为MyBatis工作的主要顶层API,表示和数据库交互的会话,完成必要数据库增删改查功能 Executor MyBatis执行器,是MyBatis调度的核心,负责SQL语句的生成和查询缓 ...
  • Nginx核心知识梳理

    2021-03-30 20:33:39
    调整worker_processes 指nginx要生成的worker数量,一般和cpu的核心数设置一致,高并发可以和cpu核心2倍. cat /proc/cpuinfo 2.优化nginx服务进程均匀分配到不同cpu进行处理。 利用worker_cpu_affinity进行优化让cpu...
  • MyBatis核心知识梳理

    2019-06-11 14:32:54
  • 如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新...
  • https://blog.csdn.net/laoyang360/article/details/52244917 转载于:https://www.cnblogs.com/sjhsszl/p/9007808.html
  • Java核心知识梳理之JVM

    2020-08-31 14:48:36
    JVM1.1JVM中的线程1.2JVM内存区域1.2.1程序计数器1.2.2虚拟机栈1.2.3程序计数器1.2.4堆1.2.5方法区/永久代 (1)基本概念: JVM是可运行Java代码的假想计算机,包括一套字节码指令集,一组寄存器,一个栈,一个垃圾回收,堆...
  • 这使得模型的含义足够丰富,结构足够清晰,可以捕捉到基本的业务知识,并有效 地使用这些知识。 2. THE SMART UI“反模式” 如果一个经验并不丰富的项目团队要完成一个简单的项目,却决定使用MODEL-DRIVEN DESIGN...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,602
精华内容 640
关键字:

核心知识梳理