绑定服务(Bound Services)概述

绑定服务是client-server接口中的服务器。它允许组件(例如活动)绑定到服务、发送请求、接收响应和执行进程间通信(IPC)。 绑定服务通常仅在它为另一个应用程序组件提供服务时才存在，并且不会无限期地在后台运行。

💥 基础知识

绑定服务是 Service 类的实现，它允许其他应用程序绑定到它并与之交互。 要为服务提供绑定，你必须实现 onBind() 回调方法。 此方法返回一个 IBinder 对象，该对象定义了客户端可用于与服务交互的编程接口。

🔥 Messenger

💥 概述

一提到IPC 很多人的反应都是 AIDL，其实如果仅仅是多进程单线程，那么你可以使用 Messenger 为你的服务提供接口。

使用 Messenger 比使用 AIDL 更简单，因为 Messenger 会将所有对服务的调用排入队列。

对于大多数应用程序，该服务不需要执行多线程，因此使用 Messenger 允许该服务一次处理一个调用。如果你的 服务多线程很重要，那你就要用到ALDL了。

💥 使用 Messenger 步骤

• 
  

  1、该 Service 实现了一个 Handler，该 Handler 接收来自客户端的每次调用的回调。

  
  


• 
  

  2、该服务使用 Handler 创建一个 Messenger 对象（它是对 Handler 的引用）。

  
  


• 
  

  3、Messenger 创建一个 IBinder，该服务从 onBind() 返回给客户端。

  
  


• 
  

  4、客户端使用 IBinder 来实例化 Messenger（引用服务的Handler），客户端使用 Handler 来向服务发送 Message 对象。

  
  


• 
  

  5、服务在其 Handler 的 handleMessage() 中接收每个消息。

  
  

💥 实例(Client到Server数据传递)

🌀 MessengerService.java

public class MessengerService extends Service {

    public static final int MSG_SAY_HELLO = 0;

    //让客户端向IncomingHandler发送消息。

    Messenger messenger = null;



    //当绑定到服务时，我们向我们的Messenger返回一个接口，用于向服务发送消息。

    public IBinder onBind(Intent intent) {

        MLog.e("MessengerService:onBind");

        //创建 Messenger 对象（对 Handler 的引用）

        messenger = new Messenger(new IncomingHander(this));

        //返回支持此Messenger的IBinder。

        return messenger.getBinder();

    }

    //实现了一个 Handler

    static class  IncomingHander extends Handler {

        private Context appliacationContext;

        public IncomingHander(Context context) {

            appliacationContext = context.getApplicationContext();

        }



        @Override

        public void handleMessage(Message msg) {

            switch (msg.what){

                case MSG_SAY_HELLO:

                    Bundle bundle = msg.getData();

                    String string = bundle.getString("name");

                    //处理来自客户端的消息

                    MLog.e("handleMessage:来自Acitvity的"+string);

                    break;

                case 1:

                    

                    break;

                default:

                    super.handleMessage(msg);

            }

        }

    }

}

🌀 AndroidMainfest.xml

        <service android:name=".ipc.MessengerService"

            android:process="com.scc.ipc.messengerservice"

            android:exported="true"

            android:enabled="true"/>

使用 android:process 属性 创建不同进程。

🌀 MainActivity.class

public class MainActivity extends ActivityBase implements View.OnClickListener {

    Messenger mService = null;

    Messenger messenger = null;

    private boolean bound;

    private ViewStub v_stud;



    @Override

    public void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        ...

    }



    ServiceConnection connection = new ServiceConnection() {

        @Override

        public void onServiceConnected(ComponentName name, IBinder service) {

            //从原始 IBinder 创建一个 Messenger，该 IBinder 之前已使用 getBinder 检索到。

            mService = new Messenger(service);

            bound = true;

        }



        @Override

        public void onServiceDisconnected(ComponentName name) {

            bound = false;

        }

    };



    @Override

    public void onClick(View v) {

        switch (v.getId()) {

            case R.id.btn_bind_service:

                bindService(new Intent(MainActivity.this, MessengerService.class), connection, Context.BIND_AUTO_CREATE);

                break;

            case R.id.btn_send_msg:

                Message message = Message.obtain(null, MessengerService.MSG_SAY_HELLO);

                Bundle bundle = new Bundle();

                bundle.putString("name","Scc");

                message.setData(bundle);

                try {

                    mService.send(message);

                } catch (RemoteException e) {

                    e.printStackTrace();

                }

                break;



        }

    }

    @Override

    protected void onStop() {

        super.onStop();

        if (bound) {

            unbindService(connection);

            bound = false;

        }

    }

}

🌀 运行效果如下

两个进程也存在着，也完成了进程间的通信，并把数据传递过去了。

💥 实例(Server将数据传回Client)

我不仅想将消息传递给 Server ，还想让 Server 将数据处理后传会Client。

🌀 MessengerService.java

public class MessengerService extends Service {

    /** 用于显示和隐藏我们的通知。 */

    ArrayList<Messenger> mClients = new ArrayList<Messenger>();

    /** 保存客户端设置的最后一个值。 */

    int mValue = 0;



    /**

     * 数组中添加 Messenger (来自客户端)。

     * Message 的 replyTo 字段必须是应该发送回调的客户端的 Messenger。

     */

    public static final int MSG_REGISTER_CLIENT = 1;



    /**

     * 数组中删除 Messenger (来自客户端)。

     * Message 的 replyTo 字段必须是之前用 MSG_REGISTER_CLIENT 给出的客户端的 Messenger。

     */

    public static final int MSG_UNREGISTER_CLIENT = 2;

    /**

     * 用于设置新值。

     * 这可以发送到服务以提供新值，并将由服务发送给具有新值的任何注册客户端。

     */

    public static final int MSG_SET_VALUE = 3;

    //让客户端向IncomingHandler发送消息。

    Messenger messenger = null;



    //当绑定到服务时，我们向我们的Messenger返回一个接口，用于向服务发送消息。

    public IBinder onBind(Intent intent) {

        MLog.e("MessengerService-onBind");

        //创建 Messenger 对象（对 Handler 的引用）

        messenger = new Messenger(new IncomingHander(this));

        //返回支持此Messenger的IBinder。

        return messenger.getBinder();

    }

    //实现了一个 Handler

    class  IncomingHander extends Handler {

        private Context appliacationContext;

        public IncomingHander(Context context) {

            appliacationContext = context.getApplicationContext();

        }



        @Override

        public void handleMessage(Message msg) {

            switch (msg.what){

                case MSG_REGISTER_CLIENT:

                    mClients.add(msg.replyTo);

                    break;

                case MSG_UNREGISTER_CLIENT:

                    mClients.remove(msg.replyTo);

                    break;

                case MSG_SET_VALUE:

                    mValue = msg.arg1;

                    for (int i=mClients.size()-1; i>=0; i--) {

                        try {

                            mClients.get(i).send(Message.obtain(null,

                                    MSG_SET_VALUE, mValue, 0));

                        } catch (RemoteException e) {

                            // 客户端没了。 从列表中删除它;

                            //从后往前安全，从前往后遍历数组越界。

                            mClients.remove(i);

                        }

                    }

                default:

                    super.handleMessage(msg);

            }

        }

    }

}

🌀 MainActivity.java

public class MainActivity extends ActivityBase implements View.OnClickListener {

    Messenger mService = null;

    Messenger messenger = null;

    private boolean bound;

    private ViewStub v_stud;



    @Override

    public void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        ...

    }



    ServiceConnection connection = new ServiceConnection() {

        @Override

        public void onServiceConnected(ComponentName name, IBinder service) {

            //从原始 IBinder 创建一个 Messenger，该 IBinder 之前已使用 getBinder 检索到。

            mService = new Messenger(service);

            bound = true;

        }



        @Override

        public void onServiceDisconnected(ComponentName name) {

            bound = false;

        }

    };

    static class ReturnHander extends Handler {

        @Override

        public void handleMessage(Message msg) {

            switch (msg.what) {

                case MessengerService.MSG_SET_VALUE:

                    //我要起飞：此处处理

                    MLog.e("Received from service: " + msg.arg1);

                    break;

                default:

                    super.handleMessage(msg);

            }

        }

    }

    @Override

    public void onClick(View v) {

        switch (v.getId()) {

            case R.id.btn_bind_service:

                bindService(new Intent(MainActivity.this, MessengerService.class), connection, Context.BIND_AUTO_CREATE);

                break;

            case R.id.btn_send_msg:

                try {

                    mMessenger = new Messenger(new ReturnHander());

                    Message msg = Message.obtain(null,

                            MessengerService.MSG_REGISTER_CLIENT);

                    msg.replyTo = mMessenger;

                    //先发一则消息添加Messenger：msg.replyTo = mMessenger;

                    mService.send(msg);



                    // Give it some value as an example.

                    msg = Message.obtain(null,

                            MessengerService.MSG_SET_VALUE, this.hashCode(), 0);

                    //传入的arg1值:this.hashCode()

                    mService.send(msg);

                } catch (RemoteException e) {

                    e.printStackTrace();

                }

                break;



        }

    }

    @Override

    protected void onStop() {

        super.onStop();

        if (bound) {

            unbindService(connection);

            bound = false;

        }

    }

}

🌀 运行效果如下

我们在MainActivity 的 Handler.sendMessger()中接收到了来自 MesengerService 的消息 。

本次 Messenger 进程间通信齐活，这只是个简单的Demo。最后咱们看一波源码。

🔥 Messenger 源码

Messenger.java

public final class Messenger implements Parcelable {

    private final IMessenger mTarget;

    public Messenger(Handler target) {

        mTarget = target.getIMessenger();

    }

    public void send(Message message) throws RemoteException {

        mTarget.send(message);

    }

    public IBinder getBinder() {

        return mTarget.asBinder();

    }

    ...

    public Messenger(IBinder target) {

        mTarget = IMessenger.Stub.asInterface(target);

    }

}

然后你会发现 只要代码还是在 IMessenger 里面，咱们去找找。

IMessenger.aidl

package android.os;



import android.os.Message;



/** @hide */

oneway interface IMessenger {

    void send(in Message msg);

}

new Messenger(Handler handelr)

这里其实是用Handler 调用 getIMessenger() 。咱们去Handler.class里面转转。

    @UnsupportedAppUsage

    final IMessenger getIMessenger() {

        synchronized (mQueue) {

            if (mMessenger != null) {

                return mMessenger;

            }

            mMessenger = new MessengerImpl();

            return mMessenger;

        }

    }

    //创建了Messenger实现类

    private final class MessengerImpl extends IMessenger.Stub {

        public void send(Message msg) {

            msg.sendingUid = Binder.getCallingUid();

            //Messenger调用send()方法，通过Handler发送消息。

            //然后在服务端通过Handler的handleMessge(msg)接收这个消息。

            Handler.this.sendMessage(msg);

        }

    }

new Messenger(IBinder target)

package android.os;

/** @hide */

public interface IMessenger extends android.os.IInterface

{

  /** Default implementation for IMessenger. */

  public static class Default implements android.os.IMessenger

  {

    @Override public void send(android.os.Message msg) throws android.os.RemoteException

    {

    }

    @Override

    public android.os.IBinder asBinder() {

      return null;

    }

  }

  /** Local-side IPC implementation stub class. */

  public static abstract class Stub extends android.os.Binder implements android.os.IMessenger

  {

    /** Construct the stub at attach it to the interface. */

    public Stub()

    {

      this.attachInterface(this, DESCRIPTOR);

    }

    /**

     * Cast an IBinder object into an android.os.IMessenger interface,

     * generating a proxy if needed.

     */

    public static android.os.IMessenger asInterface(android.os.IBinder obj)

    {

      if ((obj==null)) {

        return null;

      }

      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);

      //判断是否在同一进程。

      if (((iin!=null)&&(iin instanceof android.os.IMessenger))) {

        //同一进程

        return ((android.os.IMessenger)iin);

      }

      //代理对象

      return new android.os.IMessenger.Stub.Proxy(obj);

    }

    @Override public android.os.IBinder asBinder()

    {

      return this;

    }

    ...

  }

  public void send(android.os.Message msg) throws android.os.RemoteException;

}

看了上面代码你会发现这不就是个aidl吗？ 什么是aidl，咱们下一篇继续讲到。

背景

昨天一个我高中的女同桌突然发微信问我“你是不是程序猿 我有问题求助”，

先是激动后是茫然再是冷静，毕业多年不见联系，突然发个信息求助，感觉大脑有点反应不过来... 再说我一个搞Android的也不咋会python啊（不是说Java不能实现，大家懂的，人生苦短，我用python），即使如此，
为了大家的面子，为了程序猿们的脸，不就简单的小Python嘛，必须答应！

梳理需求

现有excel表格记录着 有效图片的名字，如：

要从一个文件夹里把excel表格里记录名字的图片筛选出来；

需求也不是很难，代码思路就有了：

1. 读取Excel表格第一列的信息并放入A集合


2. 遍历文件夹下所有的文件，判断文件名字是否存在A集合


3. 存在A集合则拷贝到目标文件夹

实现（Python 2.7）

读取Excel表格

加载Excel表格的方法有很多种，例如pandas、xlrd、openpyxl，我这里选择openpyxl库，
先安装库

pip install openpyxl

代码如下：

from openpyxl import load_workbook



def handler_excel(filename=r'C:/Users/xxx/Desktop/haha.xlsx'):

    # 根据文件路径加载一个excel表格，这里包含所有的sheet

    excel = load_workbook(filename)

    # 根据sheet名称加载对应的table

    table = excel.get_sheet_by_name('Sheet1')

    imgnames = []

    # 读取所有列 

    for column in table.columns:

        for cell in column:

            imgnames.append(cell.value+".png")

    # 选择图片

    pickImg(imgnames)

遍历文件夹读取文件名，找到target并拷贝

使用os.listdir 方法遍历文件，这里注意windows环境下拿到的unicode编码，需要GBK重新解码

def pickImg(pickImageNames):

    # 遍历所有图片集的文件名

    for image in os.listdir(

            r"C:\Users\xxx\Desktop\work\img"):

        # 使用gbk解码，不然中文乱码

        u_file = image.decode('gbk')

        print(u_file)

        if u_file in pickImageNames:

            oldname = r"C:\Users\xxx\Desktop\work\img/" + image

            newname = r"C:\Users\xxx\Desktop\work\target/" + image

            # 文件拷贝

            shutil.copyfile(oldname, newname)

简单搞定！没有砸程序猿的招牌，豪横的把成果发给女同桌，结果：

换来有机会请你吃饭，微信都不带回的，哎 ，xdm，小丑竟是我自己！

在电商、支付等领域，往往会有这样的场景，用户下单后放弃支付了，那这笔订单会在指定的时间段后进行关闭操作，细心的你一定发现了像某宝、某东都有这样的逻辑，而且时间很准确，误差在1s内；那他们是怎么实现的呢？

一般的做法有如下几种

定时任务关闭订单

rocketmq延迟队列

rabbitmq死信队列

时间轮算法

redis过期监听

一、定时任务关闭订单（最low）

一般情况下，最不推荐的方式就是关单方式就是定时任务方式，原因我们可以看下面的图来说明

我们假设，关单时间为下单后10分钟，定时任务间隔也是10分钟；通过上图我们看出，如果在第1分钟下单，在第20分钟的时候才能被扫描到执行关单操作，这样误差达到10分钟，这在很多场景下是不可接受的，另外需要频繁扫描主订单号造成网络IO和磁盘IO的消耗，对实时交易造成一定的冲击，所以PASS

二、rocketmq延迟队列方式

延迟消息
生产者把消息发送到消息服务器后，并不希望被立即消费，而是等待指定时间后才可以被消费者消费，这类消息通常被称为延迟消息。
在RocketMQ开源版本中，支持延迟消息，但是不支持任意时间精度的延迟消息，只支持特定级别的延迟消息。
消息延迟级别分别为1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h，共18个级别。

发送延迟消息（生产者）

/**

     * 推送延迟消息

     * @param topic 

     * @param body 

     * @param producerGroup 

     * @return boolean

     */

    public boolean sendMessage(String topic, String body, String producerGroup)

    {

        try

        {

            Message recordMsg = new Message(topic, body.getBytes());

            producer.setProducerGroup(producerGroup);



            //设置消息延迟级别，我这里设置14，对应就是延时10分钟

            // "1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h"

            recordMsg.setDelayTimeLevel(14);

            // 发送消息到一个Broker

            SendResult sendResult = producer.send(recordMsg);

            // 通过sendResult返回消息是否成功送达

            log.info("发送延迟消息结果：======sendResult：{}", sendResult);

            DateFormat format =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

            log.info("发送时间：{}", format.format(new Date()));



            return true;

        }

        catch (Exception e)

        {

            e.printStackTrace();

            log.error("延迟消息队列推送消息异常:{},推送内容:{}", e.getMessage(), body);

        }

        return false;

    }

消费延迟消息（消费者）

/**

     * 接收延迟消息

     * 

     * @param topic

     * @param consumerGroup

     * @param messageHandler

     */

    public void messageListener(String topic, String consumerGroup, MessageListenerConcurrently messageHandler)

{

        ThreadPoolUtil.execute(() ->

        {

            try

            {

                DefaultMQPushConsumer consumer = new DefaultMQPushConsumer();

                consumer.setConsumerGroup(consumerGroup);

                consumer.setVipChannelEnabled(false);

                consumer.setNamesrvAddr(address);

                //设置消费者拉取消息的策略，*表示消费该topic下的所有消息，也可以指定tag进行消息过滤

                consumer.subscribe(topic, "*");

                //消费者端启动消息监听，一旦生产者发送消息被监听到，就打印消息，和rabbitmq中的handlerDelivery类似

                consumer.registerMessageListener(messageHandler);

                consumer.start();

                log.info("启动延迟消息队列监听成功:" + topic);

            }

            catch (MQClientException e)

            {

                log.error("启动延迟消息队列监听失败:{}", e.getErrorMessage());

                System.exit(1);

            }

        });

    }

实现监听类，处理具体逻辑

/**

 * 延迟消息监听

 * 

 */

@Component

public class CourseOrderTimeoutListener implements ApplicationListener

{



    @Resource

    private MQUtil mqUtil;



    @Resource

    private CourseOrderTimeoutHandler courseOrderTimeoutHandler;



    @Override

    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent)

{

        // 订单超时监听

        mqUtil.messageListener(EnumTopic.ORDER_TIMEOUT, EnumGroup.ORDER_TIMEOUT_GROUP, courseOrderTimeoutHandler);

    }

}

/**

 *  实现监听

 */

@Slf4j

@Component

public class CourseOrderTimeoutHandler implements MessageListenerConcurrently

{



    @Override

    public ConsumeConcurrentlyStatus consumeMessage(List list, ConsumeConcurrentlyContext consumeConcurrentlyContext) {

        for (MessageExt msg : list)

        {

            // 得到消息体

            String body = new String(msg.getBody());

            JSONObject userJson = JSONObject.parseObject(body);

            TCourseBuy courseBuyDetails = JSON.toJavaObject(userJson, TCourseBuy.class);



            // 处理具体的业务逻辑，，，，，



      DateFormat format =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

           log.info("消费时间：{}", format.format(new Date()));

           

        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;

    }

}

这种方式相比定时任务好了很多，但是有一个致命的缺点，就是延迟等级只有18种（商业版本支持自定义时间），如果我们想把关闭订单时间设置在15分钟该如何处理呢？显然不够灵活。

三、rabbitmq死信队列的方式

Rabbitmq本身是没有延迟队列的，只能通过Rabbitmq本身队列的特性来实现，想要Rabbitmq实现延迟队列，需要使用Rabbitmq的死信交换机（Exchange）和消息的存活时间TTL（Time To Live）

死信交换机
一个消息在满足如下条件下，会进死信交换机，记住这里是交换机而不是队列，一个交换机可以对应很多队列。

一个消息被Consumer拒收了，并且reject方法的参数里requeue是false。也就是说不会被再次放在队列里，被其他消费者使用。
上面的消息的TTL到了，消息过期了。

队列的长度限制满了。排在前面的消息会被丢弃或者扔到死信路由上。
死信交换机就是普通的交换机，只是因为我们把过期的消息扔进去，所以叫死信交换机，并不是说死信交换机是某种特定的交换机

消息TTL（消息存活时间）
消息的TTL就是消息的存活时间。RabbitMQ可以对队列和消息分别设置TTL。对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的设置。超过了这个时间，我们认为这个消息就死了，称之为死信。如果队列设置了，消息也设置了，那么会取值较小的。所以一个消息如果被路由到不同的队列中，这个消息死亡的时间有可能不一样（不同的队列设置）。这里单讲单个消息的TTL，因为它才是实现延迟任务的关键。

byte[] messageBodyBytes = "Hello, world!".getBytes();  

AMQP.BasicProperties properties = new AMQP.BasicProperties();  

properties.setExpiration("60000");  

channel.basicPublish("my-exchange", "queue-key", properties, messageBodyBytes);  

可以通过设置消息的expiration字段或者x-message-ttl属性来设置时间，两者是一样的效果。只是expiration字段是字符串参数，所以要写个int类型的字符串：当上面的消息扔到队列中后，过了60秒，如果没有被消费，它就死了。不会被消费者消费到。这个消息后面的，没有“死掉”的消息对顶上来，被消费者消费。死信在队列中并不会被删除和释放，它会被统计到队列的消息数中去

处理流程图

创建交换机（Exchanges）和队列（Queues）

创建死信交换机

如图所示，就是创建一个普通的交换机，这里为了方便区分，把交换机的名字取为：delay

创建自动过期消息队列
这个队列的主要作用是让消息定时过期的，比如我们需要2小时候关闭订单，我们就需要把消息放进这个队列里面，把消息过期时间设置为2小时

创建一个一个名为delay_queue1的自动过期的队列，当然图片上面的参数并不会让消息自动过期，因为我们并没有设置x-message-ttl参数，如果整个队列的消息有消息都是相同的，可以设置，这里为了灵活，所以并没有设置，另外两个参数x-dead-letter-exchange代表消息过期后，消息要进入的交换机，这里配置的是delay，也就是死信交换机，x-dead-letter-routing-key是配置消息过期后，进入死信交换机的routing-key,跟发送消息的routing-key一个道理，根据这个key将消息放入不同的队列

创建消息处理队列
这个队列才是真正处理消息的队列，所有进入这个队列的消息都会被处理

消息队列的名字为delay_queue2
消息队列绑定到交换机
进入交换机详情页面，将创建的2个队列（delayqueue1和delayqueue2）绑定到交换机上面

自动过期消息队列的routing key 设置为delay
绑定delayqueue2

delayqueue2 的key要设置为创建自动过期的队列的x-dead-letter-routing-key参数，这样当消息过期的时候就可以自动把消息放入delay_queue2这个队列中了
绑定后的管理页面如下图：

当然这个绑定也可以使用代码来实现，只是为了直观表现，所以本文使用的管理平台来操作
发送消息

String msg = "hello word";  

MessageProperties messageProperties = newMessageProperties();  

messageProperties.setExpiration("6000");

messageProperties.setCorrelationId(UUID.randomUUID().toString().getBytes());

Message message = newMessage(msg.getBytes(), messageProperties);

rabbitTemplate.convertAndSend("delay", "delay",message);

设置了让消息6秒后过期
注意：因为要让消息自动过期，所以一定不能设置delay_queue1的监听，不能让这个队列里面的消息被接受到，否则消息一旦被消费，就不存在过期了

接收消息
接收消息配置好delay_queue2的监听就好了

package wang.raye.rabbitmq.demo1;

import org.springframework.amqp.core.AcknowledgeMode;  

import org.springframework.amqp.core.Binding;  

import org.springframework.amqp.core.BindingBuilder;  

import org.springframework.amqp.core.DirectExchange;  

import org.springframework.amqp.core.Message;  

import org.springframework.amqp.core.Queue;  

import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;  

import org.springframework.amqp.rabbit.connection.ConnectionFactory;  

import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;  

import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;  

import org.springframework.beans.factory.annotation.Autowired;  

import org.springframework.context.annotation.Bean;  

import org.springframework.context.annotation.Configuration;

@Configuration

publicclassDelayQueue{  

    /** 消息交换机的名字*/

    publicstaticfinalString EXCHANGE = "delay";

    /** 队列key1*/

    publicstaticfinalString ROUTINGKEY1 = "delay";

    /** 队列key2*/

    publicstaticfinalString ROUTINGKEY2 = "delay_key";

    /**

     * 配置链接信息

     * @return

     */

    @Bean

    publicConnectionFactory connectionFactory() {

        CachingConnectionFactory connectionFactory = newCachingConnectionFactory("120.76.237.8",5672);

        connectionFactory.setUsername("kberp");

        connectionFactory.setPassword("kberp");

        connectionFactory.setVirtualHost("/");

        connectionFactory.setPublisherConfirms(true); // 必须要设置

        return connectionFactory;

    }

    /**  

     * 配置消息交换机

     * 针对消费者配置  

        FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念  

        HeadersExchange ：通过添加属性key-value匹配  

        DirectExchange:按照routingkey分发到指定队列  

        TopicExchange:多关键字匹配  

     */  

    @Bean  

    publicDirectExchange defaultExchange() {  

        returnnewDirectExchange(EXCHANGE, true, false);

    }

    /**

     * 配置消息队列2

     * 针对消费者配置  

     * @return

     */

    @Bean

    publicQueue queue() {  

       returnnewQueue("delay_queue2", true); //队列持久  

    }

    /**

     * 将消息队列2与交换机绑定

     * 针对消费者配置  

     * @return

     */

    @Bean  

    @Autowired

    publicBinding binding() {  

        returnBindingBuilder.bind(queue()).to(defaultExchange()).with(DelayQueue.ROUTINGKEY2);  

    }

    /**

     * 接受消息的监听，这个监听会接受消息队列1的消息

     * 针对消费者配置  

     * @return

     */

    @Bean  

    @Autowired

    publicSimpleMessageListenerContainer messageContainer2(ConnectionFactory connectionFactory) {  

        SimpleMessageListenerContainer container = newSimpleMessageListenerContainer(connectionFactory());  

        container.setQueues(queue());  

        container.setExposeListenerChannel(true);  

        container.setMaxConcurrentConsumers(1);  

        container.setConcurrentConsumers(1);  

        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认  

        container.setMessageListener(newChannelAwareMessageListener() {

            publicvoid onMessage(Message message, com.rabbitmq.client.Channel channel) throwsException{

                byte[] body = message.getBody();  

                System.out.println("delay_queue2 收到消息 : "+ newString(body));  

                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费  

            }  

        });  

        return container;  

    }  

}

这种方式可以自定义进入死信队列的时间；是不是很完美，但是有的小伙伴的情况是消息中间件就是rocketmq，公司也不可能会用商业版，怎么办？那就进入下一节

四、时间轮算法

(1)创建环形队列，例如可以创建一个包含3600个slot的环形队列(本质是个数组)

(2)任务集合，环上每一个slot是一个Set
同时，启动一个timer，这个timer每隔1s，在上述环形队列中移动一格，有一个Current Index指针来标识正在检测的slot。

Task结构中有两个很重要的属性：
(1)Cycle-Num：当Current Index第几圈扫描到这个Slot时，执行任务
(2)订单号，要关闭的订单号（也可以是其他信息，比如：是一个基于某个订单号的任务）

假设当前Current Index指向第0格，例如在3610秒之后，有一个订单需要关闭，只需：
(1)计算这个订单应该放在哪一个slot，当我们计算的时候现在指向1，3610秒之后，应该是第10格，所以这个Task应该放在第10个slot的Set中
(2)计算这个Task的Cycle-Num，由于环形队列是3600格(每秒移动一格，正好1小时)，这个任务是3610秒后执行，所以应该绕3610/3600=1圈之后再执行，于是Cycle-Num=1

Current Index不停的移动，每秒移动到一个新slot，这个slot中对应的Set，每个Task看Cycle-Num是不是0：
(1)如果不是0，说明还需要多移动几圈，将Cycle-Num减1
(2)如果是0，说明马上要执行这个关单Task了，取出订单号执行关单(可以用单独的线程来执行Task)，并把这个订单信息从Set中删除即可。
(1)无需再轮询全部订单，效率高
(2)一个订单，任务只执行一次
(3)时效性好，精确到秒(控制timer移动频率可以控制精度)

五、redis过期监听

1.修改redis.windows.conf配置文件中notify-keyspace-events的值
默认配置notify-keyspace-events的值为 ""
修改为 notify-keyspace-events Ex 这样便开启了过期事件

2. 创建配置类RedisListenerConfig（配置RedisMessageListenerContainer这个Bean）

package com.zjt.shop.config;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

 

 

@Configuration

public class RedisListenerConfig {

 

    @Autowired

    private RedisTemplate redisTemplate;

 

    /**

     * @return

     */

    @Bean

    public RedisTemplate redisTemplateInit() {

 

        // key序列化

        redisTemplate.setKeySerializer(new StringRedisSerializer());

 

        //val实例化

        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

 

        return redisTemplate;

    }

 

    @Bean

    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();

        container.setConnectionFactory(connectionFactory);

        return container;

    }

 

}

3.继承KeyExpirationEventMessageListener创建redis过期事件的监听类

package com.zjt.shop.common.util;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;

import com.zjt.shop.modules.order.service.OrderInfoService;

import com.zjt.shop.modules.product.entity.OrderInfoEntity;

import com.zjt.shop.modules.product.mapper.OrderInfoMapper;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.connection.Message;

import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;

import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import org.springframework.stereotype.Component;

 



@Slf4j

@Component

public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {

 

    public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {

        super(listenerContainer);

    }

 

    @Autowired

    private OrderInfoMapper orderInfoMapper;

 

    /**

     * 针对redis数据失效事件，进行数据处理

     * @param message

     * @param pattern

     */

    @Override

    public void onMessage(Message message, byte[] pattern) {

      try {

          String key = message.toString();

          //从失效key中筛选代表订单失效的key

          if (key != null && key.startsWith("order_")) {

              //截取订单号，查询订单，如果是未支付状态则为-取消订单

              String orderNo = key.substring(6);

              QueryWrapper queryWrapper = new QueryWrapper<>();

              queryWrapper.eq("order_no",orderNo);

              OrderInfoEntity orderInfo = orderInfoMapper.selectOne(queryWrapper);

              if (orderInfo != null) {

                  if (orderInfo.getOrderState() == 0) {   //待支付

                      orderInfo.setOrderState(4);         //已取消

                      orderInfoMapper.updateById(orderInfo);

                      log.info("订单号为【" + orderNo + "】超时未支付-自动修改为已取消状态");

                  }

              }

          }

      } catch (Exception e) {

          e.printStackTrace();

          log.error("【修改支付订单过期状态异常】：" + e.getMessage());

      }

    }

}

4：测试
通过redis客户端存一个有效时间为3s的订单：

结果：

总结：
以上方法只是个人对于关单的一些想法，可能有些地方有疏漏，请在公众号直接留言进行指出，当然如果你有更好的关单方式也可以随时沟通交流

前言

最近在学习typescript，也就是我们常说的TS，它是JS的超集。具体介绍就不多说了，今天主要是带大家用webpack从零搭建一个TS开发环境。直接用传统的tsc xx.ts文件进行编译的话太繁琐，不利于我们开发，经过这次手动配置，我们也能知道vue3内部对TS的webpack进行了怎样的配置，废话不多说进入正题。

Node 编译TS

先讲讲如何运行ts文件吧，最传统的方式当然是直接输入命令

tsc xxx.ts

当然你必须得先安装过ts，如果没有请执行以下命令

npm install typescript -g

安装后查看下版本

tsc --version

这样我们就能得到编译后的js文件了，然后我们可以通过node指令

node xxx.js

进行查看，当然也可以新建一个HTML页面引入编译后的js文件

我们从上可以发现有点小复杂，那可不可以直接通过Node直接编译TS呢？接来下就是介绍这种方法

使用ts-node 就可以得到我们想要的效果

安装

npm install ts-node -g

另外ts-node需要依赖 tslib 和 @types/node 两个包,也需要下载

npm install tslib @types/node -g

现在，我们可以直接通过 ts-node 来运行TypeScript的代码

ts-node xxx.ts

如果遇到很多ts文件，那我们用这种方法也会觉得繁琐，所以我们最好是用webpack搭建一个支持TS开发环境，这样才是最好的解决方案。

webpack搭建准备工作

先新建一个文件夹

下载 webpack webpack-cli

npm install webpack webpack-cli -D

下载 ts tsloader(编译ts文件)

npm install typescript ts-loader -D

下载 webpack-dev-server(搭建本地服务器)

npm install webpack-dev-server -D

下载 html模板插件

npm install html-webpack-plugin -D

初始化webpack

npm init

初始化ts

tsc --init

新建配置文件 webpack.config.js

初始化后文件结构如下图所示，当然还有一些测试ts和html需要自己手动创建下

webpack 配置

配置之前我们先去package.json中添加两个运行和打包指令

webpack.config.js

代码中有详细说明哦

const path = require('path')//引入内置path方便得到绝对路径

const HtmlWebpackPlugin = require('html-webpack-plugin')//引入模板组件





module.exports = {

    mode: 'development',//开发模式

    entry: './src/main.ts',//入口文件地址

    output: {

        path: path.resolve(__dirname, "./dist"),//出口文件，即打包后的文件存放地址

        filename: 'bundle.js' //文件名

    },

    devServer: {



    },

    resolve: {

        extensions:['.ts', '.js', '.cjs', '.json'] //配置文件引入时省略后缀名

    },

    module: {

        rules: [

            {

                test: /\.ts$/, //匹配规则 以ts结尾的文件

                loader: 'ts-loader' //对应文件采用ts-loader进行编译

            }

        ]

    },

    plugins: [

        new HtmlWebpackPlugin({ 

            template: './index.html' //使用模板地址

        })

    ]

}

配置完成我们可以进行测试了，执行指令

npm run serve

打包指令

npm run build

End

看完的话点个赞吧~~

在初学 JS 时，发现数组拥有 shift()、unshift()、pop()、push() 这一系列方法，而不像 Java 或 CPP 中分别引用队列、栈等数据结构，还曾偷偷窃喜。现在想想，这都是以高昂的复杂度作为代价的QAQ。

举个例子 - BFS

一般队列的应用是在 BFS 题目中使用到。BFS（Breath First Search）广度优先搜索，作为入门算法，基本原理大家应该都了解，这里不再细说。

LeetCode 1765. 地图中的最高点

给你一个大小为 m x n 的整数矩阵 isWater ，它代表了一个由 陆地 和 水域 单元格组成的地图。

如果 isWater[i][j] == 0 ，格子 (i, j) 是一个 陆地 格子。
如果 isWater[i][j] == 1 ，格子 (i, j) 是一个 水域 格子。
你需要按照如下规则给每个单元格安排高度：

• 每个格子的高度都必须是非负的。


• 如果一个格子是是 水域 ，那么它的高度必须为 0 。


• 任意相邻的格子高度差 至多 为 1 。当两个格子在正东、南、西、北方向上相互紧挨着，就称它们为相邻的格子。（也就是说它们有一条公共边）

找到一种安排高度的方案，使得矩阵中的最高高度值 最大 。

请你返回一个大小为 m x n 的整数矩阵 height ，其中 height[i][j] 是格子 (i, j) 的高度。如果有多种解法，请返回 任意一个 。

常规 BFS 题目，从所有的水域出发进行遍历，找到每个点离水域的最近距离即可。常规写法，三分钟搞定。

/**

 * @param {number[][]} isWater

 * @return {number[][]}

 */

var highestPeak = function(isWater) {

    // 每个水域的高度都必须是0

    // 一个格子离最近的水域的距离 就是它的最大高度

    let n = isWater.length, m = isWater[0].length;

    let height = new Array(n).fill().map(() => new Array(m).fill(-1));

    let q = [];

    for (let i = 0; i < n; i++) {

        for (let j = 0; j < m; j++) {

            if (isWater[i][j] === 1) {

                q.push([i, j]);

                height[i][j] = 0;

            }

        }

    }

    let dir = [[0, 1], [0, -1], [1, 0], [-1, 0]];

    while (q.length) {

        for (let i = q.length - 1; i >= 0; i--) {

            let [x, y] = q.shift();

            for (let [dx, dy] of dir) {

                let nx = x + dx, ny = y + dy;

                if (nx < n && nx >= 0 && ny < m && ny >= 0 && height[nx][ny] === -1) {

                    q.push([nx, ny]);

                    height[nx][ny] = height[x][y] + 1;

                }

            }

        }

    }

    return height;

};

然后，超时了……

调整一下，

/**

 * @param {number[][]} isWater

 * @return {number[][]}

 */

var highestPeak = function(isWater) {

    // 每个水域的高度都必须是0

    // 一个格子离最近的水域的距离 就是它的最大高度

    let n = isWater.length, m = isWater[0].length;

    let height = new Array(n).fill().map(() => new Array(m).fill(-1));

    let q = [];

    for (let i = 0; i < n; i++) {

        for (let j = 0; j < m; j++) {

            if (isWater[i][j] === 1) {

                q.push([i, j]);

                height[i][j] = 0;

            }

        }

    }

    let dir = [[0, 1], [0, -1], [1, 0], [-1, 0]];

    while (q.length) {

        let tmp = [];

        for (let i = q.length - 1; i >= 0; i--) {

            let [x, y] = q[i];

            for (let [dx, dy] of dir) {

                let nx = x + dx, ny = y + dy;

                if (nx < n && nx >= 0 && ny < m && ny >= 0 && height[nx][ny] === -1) {

                    tmp.push([nx, ny]);

                    height[nx][ny] = height[x][y] + 1;

                }

            }

        }

        q = tmp;

    }

    return height;

};

ok，这回过了，而且打败了 90% 的用户。

那么问题出在哪里呢？shift()!!!

探究 JavaScript 中 shift() 的实现

在学习 C++ 的时候，队列作为一个先入先出的数据结构，入队和出队肯定都是O(1)的时间复杂度，用链表

让我们查看下 V8 中 shift() 的源码

简单实现就是

function shift(arr) {

    let len = arr.length;

    if (len === 0) {

        return;

    }

    let first = arr[0];

    for (let i = 0; i < len - 1; i++) {

        arr[i] = arr[i + 1];

    }

    arr.length = len - 1;

    return first;

}

所以，shift() 是 O(N) 的！！！ 吐血 QAQ

同理，unshift() 也是 O(N) 的，不过，pop() 和 push() 是 O(1)，也就是说把数组当做栈是没有问题的。

我就是想用队列怎么办！

没想到作为一个 JSer，想好好地用个队列都这么难……QAQ

找到了一个队列实现，详情见注释。

/*



Queue.js



A function to represent a queue



Created by Kate Morley - http://code.iamkate.com/ - and released under the terms

of the CC0 1.0 Universal legal code:



http://creativecommons.org/publicdomain/zero/1.0/legalcode



*/



/* Creates a new queue. A queue is a first-in-first-out (FIFO) data structure -

 * items are added to the end of the queue and removed from the front.

 */

function Queue(){



  // initialise the queue and offset

  var queue  = [];

  var offset = 0;



  // Returns the length of the queue.

  this.getLength = function(){

    return (queue.length - offset);

  }



  // Returns true if the queue is empty, and false otherwise.

  this.isEmpty = function(){

    return (queue.length == 0);

  }



  /* Enqueues the specified item. The parameter is:

   *

   * item - the item to enqueue

   */

  this.enqueue = function(item){

    queue.push(item);

  }



  /* Dequeues an item and returns it. If the queue is empty, the value

   * 'undefined' is returned.

   */

  this.dequeue = function(){



    // if the queue is empty, return immediately

    if (queue.length == 0) return undefined;



    // store the item at the front of the queue

    var item = queue[offset];



    // increment the offset and remove the free space if necessary

    if (++ offset * 2 >= queue.length){

      queue  = queue.slice(offset);

      offset = 0;

    }



    // return the dequeued item

    return item;



  }



  /* Returns the item at the front of the queue (without dequeuing it). If the

   * queue is empty then undefined is returned.

   */

  this.peek = function(){

    return (queue.length > 0 ? queue[offset] : undefined);

  }



}

把最初代码中的数组改为 Queue，现在终于可以通过了。:)

在实际开发过程中当我们遇到 node_modules 中的 A 包有 bug 时候，通常开发者有几个选择：

方法一：给 A 包提 issue 等待他人修复并发布：做好石沉大海或修复周期很长的准备。

方法二：给 A 包提 mr 自行修复并等待发布：很棒，不过你最好祈祷作者发版积极，并且新版本向下兼容。

方法三：把 A 包的源码拖出来自己维护：有点暴力且事后维护成本较高，不过应急时也能勉强接受。

等等，可如果出问题的包是“幽灵依赖”呢，比如项目的依赖链是： A -> B -> C，此时 C 包有 bug。那么上面三个方法的改动需要同时影响到 A、B、C 三个包，修复周期可能就更长了，可是你今晚就要上线啊，这可怎么办？

上线要紧，直接手动修改 node_modules 下的代码给缺陷包打个临时补丁吧，可问题又来了，改动只能在本地生效，构建却在云端， 积极的同学开始写起了脚本，然后陷入一个个坑里...

上述场景下即可考虑使用 patch-package 这个包，假设我们现在的源码结构如下所示：

├── node_modules  

│    └── lodash         

│        └── toString.js 

├── src                     

│    └── app.js // 依赖 lodash 的 toString 方法

└── package.json

node_modules/lodash/toString.js

var baseToString = require('./_baseToString')



function toString(value) {

  return value == null ? '' : baseToString(value);

}



module.exports = toString;

src/app.js

const toString = require('lodash/toString')

console.log(toString(123)); 

假设现在需要修改 node_modules/lodash/toString.js 文件，只需要遵循以下几步即可“优雅”完成修改：

第一步：安装依赖

yarn add patch-package postinstall-postinstall -D

第二步：修改 node_modules/lodash/toString.js 文件

function toString(value) {

	console.log('it works!!!'); // 这里插入一行代码

  return value == null ? '' : baseToString(value);

}



module.exports = toString;

第三步：生成修改文件

npx patch-package lodash

这一步运行后会生成 patches/lodash+4.17.21.patch，目录结构变成下面这样：

├── node_modules  

│    └── lodash         

│        └── toString.js 

├── patches                     

│    └── lodash+4.17.21.patch

├── src                     

│    └── app.js

└── package.json

其中 .patch 文件内容如下：

diff --git a/node_modules/lodash/toString.js b/node_modules/lodash/toString.js

index daaf681..8308e76 100644

--- a/node_modules/lodash/toString.js

+++ b/node_modules/lodash/toString.js

@@ -22,6 +22,7 @@ var baseToString = require('./_baseToString');

  * // => '1,2,3'

  */

 function toString(value) {

+  console.log('it works!!!');

   return value == null ? '' : baseToString(value);

 }

第四步：修改 package.json 文件

"scripts": {

+  "postinstall": "patch-package"

}

最后重装一下依赖，测试最终效果：

rm -rf node_modules

yarn

node ./src/app.js



// it works!!!

// 123

可以看到，即便重装依赖，我们对 node_modules 下代码的修改还是被 patch-package 还原并最终生效。

至此我们便完成一次临时打补丁的操作，不过这并非真正优雅的长久之计，长期看还是需要彻底修复第三方包缺陷并逐步移除项目中的 .patch 文件。

前言

底部导航

BottomNav组件属性

1. value

选中值（即选中BottomNavPane的name值）

值为字符串类型

非必填默认为第一个BottomNavPane的name

2. lazy

未显示的内容面板是否延迟渲染

值为布尔类型

默认为false

样式要求

组件外面需要包裹可以相对定位的元素，增加样式：position: relative

BottomNavPane组件属性

1. name

英文名称

值为字符串类型

必填

2. icon

导航图标名称

值为字符串类型

值需要与src/assets/icon目录下svg文件的名称一致（name值不含“.svg”后缀）

必填

3. label

导航图标下面显示的文字

值为字符串类型

必填

4. scroll

是否有滚动条

值为布尔类型

默认值为：true

示例

<template>

  <div class="bottom-nav-wrap">

    <BottomNav v-model="curNav" :lazy="true">

      <BottomNavPane name="home" label="首页" icon="home">

        <h1>首页内容</h1>

      </BottomNavPane>

      <BottomNavPane name="oa" label="办公" icon="logo">

        <h1>办公内容</h1>

      </BottomNavPane>

      <BottomNavPane name="page2" label="我的" icon="user">

        <h1>个人中心</h1>

      </BottomNavPane>

    </BottomNav>

  </div>

</template>



<script>

import { BottomNav, BottomNavPane } from '@/components/m/bottomNav'



export default {

  name: 'BottomNavDemo',

  components: {

    BottomNav,

    BottomNavPane

  },

  data () {

    return {

      curNav: ''

    }

  }

}

</script>



<style lang="scss" scoped>

.bottom-nav-wrap {

  position: absolute;

  top: $app-title-bar-height;

  bottom: 0;

  left: 0;

  right: 0;

}

</style>

BottomNav.vue

<template>

  <div class="bottom-nav">

    <div class="nav-pane-wrap">

      <slot></slot>

    </div>

    <div class="nav-list">

      <div class="nav-item"

           v-for="info in navInfos"

           :key="info.name"

           :class="{active: info.name === curValue}"

           @click="handleClickNav(info.name)">

        <Icon class="nav-icon" :name="info.icon"></Icon>

        <span class="nav-label">{{info.label}}</span>

      </div>

    </div>

  </div>

</template>

<script>

import { generateUUID } from '@/assets/js/utils.js'

export default {

  name: 'BottomNav',

  props: {

    // 选中导航值（导航的英文名）

    value: String,

    // 未显示的内容面板是否延迟渲染

    lazy: {

      type: Boolean,

      default: false

    }

  },

  data () {

    return {

      // 组件实例的唯一ID

      id: generateUUID(),

      // 当前选中的导航值（导航的英文名）

      curValue: this.value,

      // 导航信息数组

      navInfos: [],

      // 导航面板vue实例数组

      panes: []

    }

  },

  watch: {

    value (val) {

      this.curValue = val

    },

    curValue (val) {

      this.$eventBus.$emit('CHANGE_NAV' + this.id, val)

      this.$emit('cahnge', val)

    }

  },

  mounted () {

    this.calcPaneInstances()

  },

  beforeDestroy () {

    this.$eventBus.$off('CHANGE_NAV' + this.id)

  },

  methods: {

    // 计算导航面板实例信息

    calcPaneInstances () {

      if (this.$slots.default) {

        const paneSlots = this.$slots.default.filter(vnode => vnode.tag &&

          vnode.componentOptions && vnode.componentOptions.Ctor.options.name === 'BottomNavPane')

        const panes = paneSlots.map(({ componentInstance }) => componentInstance)

        const navInfos = paneSlots.map(({ componentInstance }) => {

          // console.log(componentInstance.name, componentInstance)

          return {

            name: componentInstance.name,

            label: componentInstance.label,

            icon: componentInstance.icon

          }

        })

        this.navInfos = navInfos

        this.panes = panes

        if (!this.curValue) {

          if (navInfos.length > 0) {

            this.curValue = navInfos[0].name

          }

        } else {

          this.$eventBus.$emit('CHANGE_NAV' + this.id, this.curValue)

        }

      }

    },

    // 导航点击事件处理方法

    handleClickNav (val) {

      this.curValue = val

    }

  }

}

</script>

<style lang="scss" scoped>

.bottom-nav {

  display: flex;

  flex-direction: column;

  height: 100%;

  .nav-pane-wrap {

    flex: 1;

  }

  .nav-list {

    flex: none;

    display: flex;

    height: 90px;

    background-color: #FFF;

    align-items: center;

    border-top: 1px solid $base-border-color;

    .nav-item {

      flex: 1;

      display: flex;

      flex-direction: column;

      align-items: center;

      line-height: 1;

      text-align: center;

      color: #666;

      .nav-icon {

        font-size: 40px;/*yes*/

      }

      .nav-label {

        margin-top: 6px;

        font-size: 24px;/*yes*/

      }

      &.active {

        position: relative;

        color: $base-color;

      }

    }

  }

}

</style>

BottomNavPane.vue

<template>

  <div v-if="canInit" class="bottom-nav-pane" v-show="show">

    <Scroll v-if="scroll">

      <slot></slot>

    </Scroll>

    <slot v-else></slot>

  </div>

</template>

<script>

import Scroll from '@/components/base/scroll'



export default {

  name: 'BottomNavPane',

  components: {

    Scroll

  },

  props: {

    // 页签英文名称

    name: {

      type: String,

      required: true

    },

    // 页签显示的标签

    label: {

      type: String,

      required: true

    },

    // 图标名称

    icon: {

      type: String,

      required: true

    },

    // 是否有滚动条

    scroll: {

      type: Boolean,

      default: true

    }

  },

  data () {

    return {

      // 是否显示

      show: false,

      // 是否已经显示过

      hasShowed: false

    }

  },

  computed: {

    canInit () {

      return (!this.$parent.lazy) || (this.$parent.lazy && this.hasShowed)

    }

  },

  created () {

    this.$eventBus.$on('CHANGE_NAV' + this.$parent.id, val => {

      if (val === this.name) {

        this.show = true

        this.hasShowed = true

      } else {

        this.show = false

      }

    })

  }

}

</script>

<style lang="scss" scoped>

.bottom-nav-pane {

  height: 100%;

  position: relative;

}

</style>

/**

 * 底部图标导航组件

 */

import BaseBottomNav from './BottomNav.vue'

import BaseBottomNavPane from './BottomNavPane.vue'

export const BottomNav = BaseBottomNav

export const BottomNavPane = BaseBottomNavPane

「欢迎在评论区讨论」

前提

前面我们学了Kotlin语言，趁热打铁我们试试Kotlin在Android中的应用。

如果是新手，请先学完Android基础。

推荐先看小空之前写的熬夜Android系列，再来尝试。

👉实践过程

😜方式一

使用扩展，如果你第一次创建项目的时候选择的是Kotlin语言，则默认带有该插件，如果选择的默认是Java语言，则需要手动添加。

该方式的优点就是对编程人员来说可以直接拿到View的id，不需要定义变量和findViewById。

在项目的build文件开头添加【app->build.gradle】

apply plugin: 'kotlin-android-extensions'

之后在Activity中添加import，固定格式的。

import kotlinx.android.synthetic.main.修改为你的布局名称.*

【*】代表的是该布局下的所有控件，如果只需要指定控件，将【*】改为控件名即可，如下示例

import kotlinx.android.synthetic.main.activity_main.*

import kotlinx.android.synthetic.main.activity_main.mytextview

之后就可以直接在代码中使用控件的id来进行响应操作了。

<TextView

        android:id="@+id/myText"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:padding="8dp"

        android:text="芝麻粒儿和空名先生"

        android:textStyle="bold"

        app:layout_constraintStart_toStartOf="parent"

        app:layout_constraintTop_toTopOf="parent" />

但是方便的同时，问题的隐患也存在着，在底层仍然回归原始使用的是findViewById，所以会对性能有影响。

😜方式二

使用findViewById，这个仍然有两种方式，方式一是【lateinit】关键字，但是存在坑，详情看这（在 Kotlin 代码中慎用 lateinit 属性zhuanlan.zhihu.com/p/31297995 ）
推荐方式二使用【lazy】，如下：

private val myText: TextView by lazy { findViewById<TextView>(R.id.myText) }

private val myImg: ImageView by lazy { findViewById<ImageView>(R.id.myImg) }

private val imageView: ImageView by lazy { findViewById<ImageView>(R.id.imageView) }

private val myBtn: Button by lazy { findViewById<Button>(R.id.myBtn) }

上面是在Activity中的使用，而在Fragment中又怎么用呢？

class LoginFragment : Fragment() {

  private var myText: TextView? = null

  override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {

        //设置布局

        return inflater.inflate(R.layout.login_fragment, container, false)

    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {

        super.onViewCreated(view, savedInstanceState)

   myText = view.findViewById(R.id.myText)

        myText?.setText("动态修改文本")

    }

}

除了上面的写法，Android官方给了我们更好的解决方案：

class LoginFragment : Fragment() {

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {

        //设置布局

        return inflater.inflate(R.layout.login_fragment, container, false)

    }



    private lateinit var myText: TextView

    private lateinit var myImg: ImageView

    private lateinit var imageView: ImageView

    private lateinit var myBtn: Button



    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {

        super.onViewCreated(view, savedInstanceState)

        //查找view

        myText = view.findViewById(R.id.myText)

        myImg = view.findViewById(R.id.myImg)

        imageView = view.findViewById(R.id.imageView)

        myBtn = view.findViewById(R.id.myBtn)

    }

}

还有另外方式就是使用自动化插件，在【File-Setting-Plugins】市场搜索关键字【findview】，看最新的几个，挑选自己用的顺手的使用即可。

一道面试题

前段时间面试，面试官先问了一下fragment的生命周期，我一看这简单呀，直接按照下图回答

面试官点点头，然后问，如果Activity里面有一个fragment，那么启动他们时，他们的生命周期加载顺序是什么？

所以今天，我们好好了解了解这个用得非常多，但是对底层不是很理解的fragment吧

首先回答面试官的问题，Fragment 的 start与activity 的start 的调用时机

调用顺序：

D/MainActivity: MainActivity:

D/MainActivity: onCreate: start

D/MainFragment: onAttach:

D/MainFragment: onCreate:

D/MainActivity: onCreate: end

D/MainFragment: onCreateView:

D/MainFragment: onViewCreated:

D/MainFragment: onActivityCreated:

D/MainFragment: onViewStateRestored:

D/MainFragment: onCreateAnimation:

D/MainFragment: onCreateAnimator:

D/MainFragment: onStart:

D/MainActivity: onStart:

D/MainActivity: onResume:

D/MainFragment: onResume:

可以看到Activity 在oncreate开始时，Fragment紧接着attach，create，然后activity执行完毕onCreate方法

此后都是Fragment在执行，直到onStart方法结束

然后轮到Activity，执行onStart onResume

也就是，Activity 创建的时候，Fragment一同创建，同时Fragment优先在后台先展示好，最后Activity带着Fragment一起展示到前台。

是什么？

Fragment中文翻译为”碎片“，在手机中，每一个Activity作为一个页面，有时候太大了，尤其是在平板的横屏下，我们希望左半边是一根独立模块，右半边是一个独立模块，比如一个新闻app，左边是标题栏，右边是显示内容

此时就非常适合Fragment

Fragment是内嵌入Activity中的，可以在onCreateView中加载自定义的布局，使用LayoutInflater，然后Activity持有FragmentManager对Fragment进行控制，下图是他的代码框架

我们的Activity一般是用AppCompatActivity，而AppCompatActivity继承了FragmentActivity

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,

        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {

也就是说Activity之所支持fragment，是因为有FragmentActivity，他内部有一个FragmentController，这个controller持有一个FragmentManager，真正做事的就是这个FragmentManager的实现类FragmentManagerImpl

整体架构

回到我们刚才的面试题，关于生命周期绝对是重中之重，但是实际上，生命周期本质只是被其他地方的方法被动调用而已，关键是Fragment自己的状态变化了，才会回调生命周期方法，所以我们来看看fragment的状态转移

static final int INITIALIZING = 0;     初始状态，Fragment 未创建

static final int CREATED = 1;          已创建状态，Fragment 视图未创建

static final int ACTIVITY_CREATED = 2; 已视图创建状态，Fragment 不可见

static final int STARTED = 3;          可见状态，Fragment 不处于前台

static final int RESUMED = 4;          前台状态，可接受用户交互

fragment有五个状态，

调用过程如下

Fragment的状态转移过程主要受到宿主，事务的影响，宿主一般就是Activity，在我们刚刚的题目中，看到了Activity与Fragment的生命周期交替执行，本质上就是，Activity执行完后通知了Fragment进行状态转移，而Fragment执行了状态转移后对应的回调了生命周期方法

下图可以更加清晰

宿主改变Fragment状态

那么我们不禁要问，Activity如何改变Fragment的状态？

我们知道Activity继承于FragmentActivity，最终是通过持有的FragmentManager来控制Fragment，我们去看看

FragmentActivity

   @Override

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        mFragments.attachHost(null /*parent*/);



        super.onCreate(savedInstanceState);

  			...

        mFragments.dispatchCreate();

}

可以看到，onCreate方法中执行了mFragments.dispatchCreate();，看起来像是通知Fragment的onCreate执行，这也印证了我们开始时的周期回调顺序

D/MainActivity: MainActivity: 

D/MainActivity: onCreate: start // 进入onCreate

D/MainFragment: onAttach: // 执行mFragments.dispatchCreate();

D/MainFragment: onCreate: 

D/MainActivity: onCreate: end // 退出onCreate

类似的FragmentActivity在每一个生命周期方法中都做了相同的事情

@Override

protected void onDestroy() {

    super.onDestroy();



    if (mViewModelStore != null && !isChangingConfigurations()) {

        mViewModelStore.clear();

    }



    mFragments.dispatchDestroy();

}

我们进入dispatchCreate看看，

Runnable mExecCommit = new Runnable() {

    @Override

    public void run() {

        execPendingActions();

    }



//内部修改了两个状态

public void dispatchCreate() {

    mStateSaved = false;

    mStopped = false;

    dispatchStateChange(Fragment.CREATED);



private void dispatchStateChange(int nextState) {

    try {

        mExecutingActions = true;

        moveToState(nextState, false);// 转移到nextState

    } finally {

        mExecutingActions = false;

    }

    execPendingActions();

}

//一路下来会执行到

void moveToState(Fragment f, int newState, int transit, int transitionStyle,

                 boolean keepActive) {

    // Fragments that are not currently added will sit in the onCreate() state.

    if ((!f.mAdded || f.mDetached) && newState > Fragment.CREATED) {

        newState = Fragment.CREATED;

    }

    if (f.mRemoving && newState > f.mState) {

        if (f.mState == Fragment.INITIALIZING && f.isInBackStack()) {

            // Allow the fragment to be created so that it can be saved later.

            newState = Fragment.CREATED;

        } else {

            // While removing a fragment, we can't change it to a higher state.

            newState = f.mState;

        }

    }

	...

}

可以看到上面的代码，最终执行到 moveToState，通过判断Fragment当前的状态，同时newState > f.mState，避免状态回退，然后进行状态转移

状态转移完成后就会触发对应的生命周期回调方法

事务管理

如果Fragment只能随着Activity的生命周期变化而变化，那就太不灵活了，所以Android给我们提供了一个独立的操作方案，事务

同样由FragManager管理，具体由FragmentTransaction执行，主要是添加删除替换Fragment等，执行操作后，需要提交来保证生效

FragmentManager fragmentManager = ...

FragmentTransaction transaction = fragmentManager.beginTransaction();

transaction.setReorderingAllowed(true);



transaction.replace(R.id.fragment_container, ExampleFragment.class, null); // 替换Fragment



transaction.commit();// 这里的commit是提交的一种方法

Android给我们的几种提交方式

FragmentTransaction是个挂名抽象类，真正的实现在BackStackState回退栈中，我们看下commit

@Override

public int commit() {

    return commitInternal(false);

}

int commitInternal(boolean allowStateLoss) {

    if (mCommitted) throw new IllegalStateException("commit already called");

  	...

    mCommitted = true;

    if (mAddToBackStack) {

        mIndex = mManager.allocBackStackIndex(this);//1

    } else {

        mIndex = -1;

    }

    // 入队操作

    mManager.enqueueAction(this, allowStateLoss);//2

    return mIndex;

}

可以看到，commit的本质就是将事务提交到队列中，这里出现了两个数组，注释1处

ArrayList<BackStackRecord> mBackStackIndices;

ArrayList<Integer> mAvailBackStackIndices;

public int allocBackStackIndex(BackStackRecord bse) {

    synchronized (this) {

        if (mAvailBackStackIndices == null || mAvailBackStackIndices.size() <= 0) {

            if (mBackStackIndices == null) {

                mBackStackIndices = new ArrayList<BackStackRecord>();

            }

            int index = mBackStackIndices.size();

            mBackStackIndices.add(bse);

            return ind

        } else {

            int index = mAvailBackStackIndices.remove(mAvailBackStackIndices.size()-1);

            mBackStackIndices.set(index, bse);

            return index;

        }

    }

}

mBackStackIndices数组，每个元素是一个回退栈，用来记录索引。比如说，当有五个BackStackState时，移除掉1,3两个，就是在mBackStackIndices将对应元素置为null，然后mAvailBackStackIndices会添加这两个回退栈，记录被移除的回退栈

当下次commit时，就判定mAvailBackStackIndices中的索引，对应的BackStackState一定是null，直接写到这个索引即可

而一组操作都commit到同一个队列里面，所以要么全部完成，要么全部不做，可以保证原子性

注释二处是一个入队操作

public void enqueueAction(OpGenerator action, boolean allowStateLoss

    synchronized (this) {

      	...

        mPendingActions.add(action);

        scheduleCommit(); // 真正的提交

    }

}

public void scheduleCommit() {

    synchronized (this) {

        boolean postponeReady =

                mPostponedTransactions != null && !mPostponedTransactions.isEmpty();

        boolean pendingReady = mPendingActions != null && mPendingActions.size() == 1;

        if (postponeReady || pendingReady) {

            mHost.getHandler().removeCallbacks(mExecCommit);

            mHost.getHandler().post(mExecCommit); // 发送请求

        }

}

这里最后 mHost.getHandler()是拿到了宿主Activity的handler，使得可以在主线程执行，mExecCommit本身是一个线程

我们继续看下这个mExecCommit

Runnable mExecCommit = new Runnable() {

    @Override

    public void run() {

        execPendingActions();

    }

};

public boolean execPendingActions() {

    ensureExecReady(true);

      ...

    doPendingDeferredStart();

    burpActive();

    return didSomething;

}

void doPendingDeferredStart() {

    if (mHavePendingDeferredStart) {

        mHavePendingDeferredStart = false;

        startPendingDeferredFragments();

    }

}

void startPendingDeferredFragments() {

    if (mActive == null) return;

    for (int i=0; i<mActive.size(); i++) {

        Fragment f = mActive.valueAt(i);

        if (f != null) {

            performPendingDeferredStart(f);

        }

    }

}

public void performPendingDeferredStart(Fragment f) {

    if (f.mDeferStart) {

        f.mDeferStart = false;

        moveToState(f, mCurState, 0, 0, false); // 最终到了MoveToState

    }

}

还记得我们在宿主改变Fragment状态，里面的最终路径吗？是的，就是这个moveToState，无论是宿主改变Fragment状态，还是事务来改变，最终都会执行到moveToState，然后call对应的生命周期方法来执行，这也是为什么我们要将状态转移作为学习主线，而不是生命周期。

除了commit，可以看到FragmentTransaction有众多对Fragment进行增删改查的方法

都是由BackStackState来执行，最后都会执行到moveToState中

具体是如何改变的，有很多细节，这里不再赘述。

小结

本节我们讲了Fragment在android系统中的状态，那就是通过自身状态转移来回调对应生命周期方法，这块是自动实现的，我们开发时不太需要关注状态转移，只要知道什么时候执行某个生命周期方法，然后再在对应方法中写业务逻辑即可

有两个方法可以让Fragment状态转移，

• 宿主Activity生命周期内自动修改Fragment状态，回调Fragment的生命周期方法


• 通过手动提交事务，修改Fragment状态，回调Fragment的生命周期方法

最近一直在做基础建设方面的工作，面对这三十多个完全没有规范可言的组件，气的我直接打了一套闪电五连鞭，但打工还得继续，于是想对这些组件建立一套规范，来降低够用、使用、维护以及扯皮成本，本想在网上白嫖一套，可找到的都是一些基础的代码规范，用处不大，于是乎根据自己的工作经验，总结出一套规范/约定出来，希望能抛砖引玉，各位大佬多多指点和补充~

规范本身就是开发人员之间的约定，没有最权威的，只有最适合的。

版本规范

为保证组件在各个项目中的兼容性问题，约定组件开发版本如下：

AndroidSdk版本

minSdkVersion：21

targetSdkVersion：28

语言环境

开发语言：Kotlin

Kotlin版本：1.4.x

JDK版本：1.8

其他建议版本

AndroidStuido：4.2

gradle tools：4.1.x

gradle：6.7.x

组件命名规范

根据组件的功能不同，约定组件分为三个类型：

基础组件

为项目提供与业务无关基础支持的组件库，如提供MVVM架构的lib_basic，提供依赖注入的lib_basic_koin，这类组件统一命名方式为lib_basic_xxx。这些基础组件也可以被工具组件和业务组件依赖，而不仅仅是只被项目依赖。

工具组件

对项目中常用的业务无关功能封装的组件库，如Dialog弹窗，相册选择等，这类组件统一命名方式为lib_util_xxx。

业务组件

在某个项目的需求中出现的在其他项目中可能也会用到的功能的封装，比如A业务员版中扫描拍照在A商业版中也有用到，于是单独封装为一个业务组件进行管理，这类组件统一命名方式为lib_tool_xxx。

GroupId

所有组件统一GroupId为com.company.android，方便在Maven仓库中进行索引和管理。

版本号

对于迭代的版本号，不做强制性的要求，只需合理进行升级即可，但以下情况需特殊注意：

1、对于上传的开发版本，需要在版本中进行体现，如1.1.0-dev02，与正式版本做区分，在项目中验证无风险后，合并到主迭代版本中。

2、对于紧急修复A项目中的问题而临时发版的，需要在版本中进行体现，如1.1.0-hotfix-A，此次修改在其他使用的项目中验证无风险后，合并到主迭代版本中。

开发原则

开闭原则

在组件升级时，应对新增开放，对修改关闭，即做加法不做减法，目的是为了保证对项目中调用老版本API的兼容问题。对于不再建议使用的API，应使用 @Deprecated注解进行标注，并新增建议使用的API进行代替，而不是直接删除旧API。在完成多个稳定版本的迭代之后，可以所有组件使用者讨论删除旧版API的事宜。

向下兼容原则

所有组件的版本迭代必须向下兼容，即1.2.0版本须兼容1.1.0，在使用者升级版本之后，无需修改业务层代码。

如果因组件前期设计不合理导致升级必须修改业务代码时，组件开发者需要与所有组件使用者商讨技术实现方案，看能否以最小的改动完成组件的升级，并在组件功能开发完毕后，以书面形式告知使用者并提供完整的升级文档。

三方隔离原则

我们在封装组件的时候，难免会使用到第三方依赖，为了避免更换三方依赖或依赖升级造成的影响，需要对三方依赖库进行二次封装，避免直接使用。比如我们要使用glide框架加载图片，可以创建一个代理类对glide的功能进行代理，在业务代码中使用代理类进行操作而不是直接调用glide，这样我们将来替换glide框架时，能最小的改动业务代码。

当然，并不是所有的三方库都通过代理模式进行隔离，比如retrofit、RxJava等，毕竟我们的隔离原则是为了以后更简单的迭代而不是自寻烦恼。

最少依赖原则

为了减少项目中依赖的类库，在组件封装中遇到如下情况，应对组件进行拆分工作：

现封装一图片加载类库lib_util_imageloader，对Glide和Picasso进行了二次封装，由于两个类库提供了类似的功能，在项目中只需要使用一套就能满足业务需求，没有必要把两个图片加载框架都进行依赖，所以应该对lib_util_imageloader进行拆分为如下结构：

lib_util_imageloader_core：图片加载核心库，把加载图片的方法抽象为接口，面向项目，不做具体的实现。

lib_util_imageloader_glide：对glide进行二次封装，实现core中的接口。

lib_util_imageloader_picasso：对picasso进行二次封装，实现core中的接口。

在项目使用图片加载库时，除了必须要依赖的core外，只需要从glide和picasso中挑选一个即可，这样就不会把用不到的类库也打包到项目中去了。

这样的做法还有一个好处，就是容易拓展。如果我想要使用Fresco,只需要再新增一个lib_util_imageloader_fresco，并实现core的接口即可，在切换组件时，只需要改变gradle文件中的依赖，无需变更业务代码，因为业务代码都是基于core组件的。

最少可见原则

组件应该尽可能少的对外暴露类、接口、方法等。可以通过外观模式对使用者统一提供API，降低使用者的理解难度。

支持开发模式

组件需要预留开发者模式，可以让使用者自行选择开启关闭。

打开开发者模式：组件运行的关键节点需进行日志输出，方便使用者进行调试，可以在运行时抛出异常。

关闭开发者模式：组件不再对外输出Error级别以下的日志，禁止在运行时抛出异常、ANR，如发生异常需要在组件内捕获并通过错误回调或打印Error级别日志等方式告知使用者。

可拓展性

部分组件（视具体情况而定，多数为对三方类库的封装组件）应该有一定的拓展性，应支持使用者自定义实现覆盖默认实现。

比如Dialog类库有默认弹窗样式，需要支持使用者自定义弹窗样式而不是只能在默认样式中进行选择，图片加载框架也是相同的逻辑。

开发规范

包名规范

为了避免无意中导致的包名冲突问题，约定组件的包名为4级，除去前两级的com.company为固定写法以外，后两级可根据具体的组件功能进行命名，并要求有良好的可读性。

资源规范

组件中定义资源文件时，要以组件名称为前缀，避免资源冲突导致的打包问题，需要在gradle文件的android节点下新增如下代码强制进行资源名称前缀检查：

android{

  resourcePrefix = "${your_component_name}_"

}

复制代码

代码规范

应当遵循Java开发代码规范，这里不再赘述。

可见域规范

Kotlin中新增关键字internal，可用于修饰类名、方法名和成员变量名，限制所修饰的对象模块内可见，对于无需对外暴露的类、方法和变量，应当降低其可见域。

内联函数

Kotlin中新增关键字inline修饰方法，可以减少方法栈的进栈方法数。在封装组件时善用inline以提高组件的运行效率。

内存泄漏

所有组件在发布之间，必须进行内存泄漏检测，禁止存在内存泄漏的组件上线，应在开发阶段修复所有泄漏问题。

混淆

组件开发者需要确认自己的组件在打包混淆后是否可以正常工作，如有用到运行时注解、反射、Json转换等功能，需要在接入文档中声明避免混淆的规则。

文档

组件的接入、使用、升级和注意事项等需要在开发文档中有明确的体现，没有接入文档或者文档不完善一律不许通过验收。

Demo

组件最好有配套的演示工程，用来最直观的体现出组件所提供的功能，也方便使用者进行参考。

最后

目前只能想起这么多，以后有新增的会继续补充。

规范好定制，落实起来却难，路漫漫其修远兮，加油吧，打工人！

效果&使用

图例分别为:

• 修改读条起点为y轴正方向


• 消失性读条


• 正常读条

使用:

• 1 在xml中添加控件

<com.lloydfinch.ProgressTrackBar

    android:id="@+id/progress_track_bar"

    android:layout_width="62dp"

    android:layout_height="62dp"

    app:p_second_color="#E91E63"

    app:p_width="3dp" />



<com.lloydfinch.ProgressTrackBar

    android:id="@+id/progress_track_bar2"

    android:layout_width="62dp"

    android:layout_height="62dp"

    app:p_first_color="#18B612"

    app:p_second_color="#00000000"

    app:p_width="3dp" />



<com.lloydfinch.ProgressTrackBar

    android:id="@+id/progress_track_bar3"

    android:layout_width="62dp"

    android:layout_height="62dp"

    app:p_first_color="#ffd864"

    app:p_second_color="#1C3F7C"

    app:p_width="3dp" />

• 2 在代码中启动倒计时

val trackBar = findViewById<ProgressTrackBar>(R.id.progress_track_bar)

trackBar.setStartAngle(-90F) // 从-90度开始读条

trackBar.setOnProgressListener { // 进度回调

    Log.d("ProgressTrackBar", "progress is $it")

}

trackBar.startTask(0) { // 开始计时，传入读条结束的回调

    Log.d("ProgressTrackBar", "progress run finish")

}



// 从0开始计时

findViewById<ProgressTrackBar>(R.id.progress_track_bar2).startTask(0)



// 从20开始计时

findViewById<ProgressTrackBar>(R.id.progress_track_bar3).startTask(20)

思路&编码

核心思路就一个: 画原环。我们要画两个圆环，一个下层的完整圆环作为底色，一个上层的圆弧作为进度。重点就是计算圆弧弧度的问题了。

假设当前进度是current，最大进度是max，那么当前圆弧进度就是:(current/max)*360，然后我们直接调用:

// oval: 放置圆弧的矩形

// startAngle: 开始绘制的起点角度，方向是顺时针计算的。0就x正半轴，90就是y轴负半轴

// sweepAngle: 要绘制的圆弧的弧度，就是上述: (current/max)x360

// false: 表示不连接到圆心，表示绘制一个圆弧

canvas.drawArc(oval, startAngle, sweepAngle, false, mPaint);

就能绘制出对应的圆弧。

所以，我们这样:

// 绘制下层: 圆形

mPaint.setColor(firstLayerColor);

canvas.drawCircle(x, y, radius, mPaint);



// 绘制上层: 圆弧

mPaint.setColor(secondLayerColor);

float sweepAngle = (currentProgress / maxProgress) * 360;

canvas.drawArc(oval, startAngle, sweepAngle, false, mPaint);

我们先用下层颜色绘制一个圆形，然后用上层颜色绘制个圆弧，然后不断触发重绘，就能得到想要的效果。

但是，如果我们想要的是: 随着进度变大，圆弧越来越短呢？比如示例图的第二个效果。说白了就是让上层随着时间流逝而变小，直到消失，怎么实现呢？

其实，说白了就是时间越长，弧度越小，我们做减法即可，我们用(max-current)来作为已读进度，这样随着时间流逝，进度就越来越小。

有人说，这样不对啊，这样(max-current)不就越读越小了吗，这样画出来的弧度就越来越短了，最后完全漏出了底层，给人的感觉是倒着读的。没错，所以，我们只绘制一层，我们用下层颜色来绘制圆弧！这样，随着时间流逝，弧度越来越小，因为圆弧是用下层颜色绘制的，所以视觉上就是: 下层越来越少。给人的感觉就是: 上层越来越大以至于盖住了下层。

逻辑如下:

// 用下层颜色 绘制 剩下的弧度

mPaint.setColor(firstLayerColor);

float leaveAngle = ((maxProgress - currentProgress) / maxProgress) * 360;

canvas.drawArc(oval, startAngle, leaveAngle, false, mPaint);

可以看到，这里只绘制一层，随着时间流逝，圆弧越来越短，给人的感觉就是: 圆弧消失。就达到了示例图中 第二个圆弧的效果。

整体代码如下:

public class ProgressTrackBar extends View {





    private static final int DEFAULT_FIRST_COLOR = Color.WHITE;

    private static final int DEFAULT_SECOND_COLOR = Color.parseColor("#FFA12F");



    private static final int PROGRESS_WIDTH = 6;

    private static final float MAX_PROGRESS = 360F;

    private static final int DEFAULT_SPEED = 1;



    private Paint mPaint;

    private float startAngle = 0;

    private int firstLayerColor = DEFAULT_FIRST_COLOR;

    private int secondLayerColor = DEFAULT_SECOND_COLOR;

    private final RectF oval = new RectF(); // 圆形轨迹

    private float maxProgress = MAX_PROGRESS; // 最大进度:ms

    private float currentProgress = 0F; // 当前进度:ms

    private int speed = DEFAULT_SPEED; // 速度(多长时间更新一次UI):ms

    private int progressWidth = PROGRESS_WIDTH; // 进度条宽度



    private OnProgressFinished onProgressFinished;



    private Handler taskHandler;

    private OnProgress runnable; //进度回调



    // 顶层颜色是否是透明

    private boolean isSecondColorTransparent = false;



    public ProgressTrackBar(Context context) {

        super(context);

        init();

    }



    public ProgressTrackBar(Context context, @Nullable AttributeSet attrs) {

        super(context, attrs);



        TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.ProgressTrackBar);

        firstLayerColor = typedArray.getColor(R.styleable.ProgressTrackBar_p_first_color, DEFAULT_FIRST_COLOR);

        secondLayerColor = typedArray.getColor(R.styleable.ProgressTrackBar_p_second_color, DEFAULT_SECOND_COLOR);

        startAngle = typedArray.getFloat(R.styleable.ProgressTrackBar_p_start, 0F);

        progressWidth = typedArray.getDimensionPixelSize(R.styleable.ProgressTrackBar_p_width, PROGRESS_WIDTH);

        maxProgress = typedArray.getDimension(R.styleable.ProgressTrackBar_p_max_progress, MAX_PROGRESS);



        typedArray.recycle();



        init();

    }



    public ProgressTrackBar(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {

        super(context, attrs, defStyleAttr);

        init();

    }



    private void init() {

        refresh();

        mPaint = new Paint();

        mPaint.setStyle(Paint.Style.STROKE);

        mPaint.setAntiAlias(true);

        mPaint.setStrokeCap(Paint.Cap.ROUND);

        mPaint.setStrokeWidth(progressWidth);

    }



    public void setFirstLayerColor(int firstLayerColor) {

        this.firstLayerColor = firstLayerColor;

    }



    public void setSecondLayerColor(int secondLayerColor) {

        this.secondLayerColor = secondLayerColor;

        refresh();

    }



    public void setMaxProgress(float maxProgress) {

        this.maxProgress = maxProgress;

    }



    public void setSpeed(int speed) {

        this.speed = speed;

    }



    public void setStartAngle(float startAngle) {

        this.startAngle = startAngle;

    }



    public void setProgressWidth(int progressWidth) {

        this.progressWidth = progressWidth;

    }



    public void setOnProgressListener(OnProgress runnable) {

        this.runnable = runnable;

    }



    public void setOnProgressFinished(OnProgressFinished onProgressFinished) {

        this.onProgressFinished = onProgressFinished;

    }



    private void initTask() {

        taskHandler = new Handler(Looper.getMainLooper()) {

            @Override

            public void handleMessage(Message msg) {

                if (currentProgress < maxProgress) {

                    currentProgress += speed;

                    postInvalidate();

                    if (runnable != null) {

                        runnable.onProgress(currentProgress);

                    }

                    taskHandler.sendEmptyMessageDelayed(0, speed);

                } else {

                    stopTask();

                }

            }

        };

    }



    private void refresh() {

        isSecondColorTransparent = (secondLayerColor == Color.parseColor("#00000000"));

    }



    @Override

    protected void onDraw(Canvas canvas) {

        super.onDraw(canvas);

        int x = getWidth() >> 1;

        int y = getHeight() >> 1;

        int center = Math.min(x, y);

        int radius = center - progressWidth;



        int left = x - radius;

        int top = y - radius;

        int right = x + radius;

        int bottom = y + radius;

        oval.set(left, top, right, bottom);



        // 这里需要处理一下上层是透明的情况

        if (isSecondColorTransparent) {

            // 用下层颜色 绘制 剩下的弧度

            mPaint.setColor(firstLayerColor);

            float leaveAngle = ((maxProgress - currentProgress) / maxProgress) * 360;

            canvas.drawArc(oval, startAngle, leaveAngle, false, mPaint);

        } else {

            // 绘制下层

            mPaint.setColor(firstLayerColor);

            canvas.drawCircle(x, y, radius, mPaint);



            // 绘制上层

            mPaint.setColor(secondLayerColor);

            float sweepAngle = (currentProgress / maxProgress) * 360;

            canvas.drawArc(oval, startAngle, sweepAngle, false, mPaint);

        }

    }



    public void startTask(int progress) {

        currentProgress = progress;

        initTask();

        taskHandler.sendEmptyMessage(0);

    }



    public void startTask(int progress, OnProgressFinished onProgressFinished) {

        this.onProgressFinished = onProgressFinished;

        currentProgress = progress;

        initTask();

        taskHandler.sendEmptyMessage(0);

    }



    public void stopTask() {

        if (onProgressFinished != null) {

            onProgressFinished.onFinished();

        }

        if (taskHandler != null) {

            taskHandler.removeCallbacksAndMessages(null);

        }

    }



    @Override

    protected void onDetachedFromWindow() {

        super.onDetachedFromWindow();

        stopTask();

    }



    public interface OnProgressFinished {

        void onFinished();

    }



    public interface OnProgress {

        void onProgress(float progress);

    }

}