爱写代码的何蜀黍
爱写代码的何蜀黍

MQTT、RxJava封装

最近物联网的项目需要做推送，功能实现方式有以下几种：

  • 轮训，我们客户端定时请求后端接口，并不是推送，缺点是耗电、耗流量。

  • 发送短信并拦截，服务端向客户端发送短信，客户端进行拦截。拦截短信需要申请权限，并且容易被安全管家类的App拦截，并且也需要耗费费用来发送短信，不可靠并且也耗财力。

  • 长连接，客户端和服务端维持一个连接（定时心跳），真正的推送。

    1. Google GCM，国内环境，不考虑。
    2. XMPP，XML格式，协议比较复杂，比较费流量，费电。
    3. MQTT，协议简洁，省流量、省点。
    4. 第三方推送，例如友盟推送、百度推送、个推等，优点是容易接入，缺点嘛暂时没发现什么缺点，不过第三方推送对于物联网可能会有个天生不足，就是物联网项目，有些政府的地方使用只能是局域网，而如果是第三方推送，服务端需要调用第三方服务端Api，再推到客户端，在局域网里面就用不了。

MQTT简介

  • MQTT使用发布、订阅的消息模式，支持一对多方式订阅。
  • 只是一种协议，消息内容并不会强制绑定，只是一个字符串，一般我们为json。
  • 使用TCP/IP提供网络连接。
  • 小型传输，开销很小（固定长度的头部是2字节），协议交换最小化，以降低网络流量。

消息发布有以下质量选择：

  1. “至多一次”，消息发布完全依赖底层TCP/IP网络。会发生消息丢失或重复。这一级别可用于如下情况，环境传感器数据，丢失一次读记录无所谓，因为不久后还会有第二次发送。这一种方式主要普通APP的推送，倘若你的智能设备在消息推送时未联网，推送过去没收到，再次联网也就收不到了。

  2. “至少一次”，确保消息到达，但消息重复可能会发生。

  3. “只有一次”，确保消息到达一次。在一些要求比较严格的计费系统中，可以使用此级别。在计费系统中，消息重复或丢失会导致不正确的结果。这种最高质量的消息发布服务还可以用于即时通讯类的APP的推送，确保用户收到且只会收到一次。

选用方案

物联网一般也使用MQTT，为了后续其他项目也方便用，需要对MQTT做一次封装，由于RxJava的Retry重试系列操作符对重连可以很简单的封装。消息一对多分发刚好RxJava的多订阅者进行消息，很容易解耦，所以将MQTT、RxJava整合封装。

第三方库

我这里采用paho.mqtt.android这个第三方库。

  • 项目根目录下的build.gradle中添加：
repositories {
    maven {
        url "https://repo.eclipse.org/content/repositories/paho-releases/"
    }
}
  • app或lib目录下的build.gradle中添加
dependencies {
    implementation 'org.eclipse.paho:org.eclipse.paho.android.service:1.1.1'
    implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.1.1'
}
  • AndroidManifest.xml清单文件中
    1. 添加权限
    2. 声明库中的MqttService服务

知识点补充

MQTT是基于发布、订阅的消息模式，支持一对多消息发布和订阅多个主题，先来说一下一些必要的知识点：

  • 主题，也叫Topic，为一个字符串，只要客户端订阅，服务端则会将这个Topic的消息推送过来，所以一个客户端订阅多个Topic则可以收到多方消息，例如广告模块推送、新闻模块推送等。例如我们用以下规则组合Topic：system/ad，system/news。

  • ClientId，客户端的唯一标识，也是一个字符串，必须唯一，否则会互相抢连接，不断断开、不断连接的情况。很容易出现这种情况，例如一个账号再多个手机上的客户端上登录就会出现该情况，所以一般为用户id+一定随机数来保证唯一。

  • 关于一对一推送，上面说到的一对多订阅，可以实现群发，对于一对于推送并没有实现，但是实现也很简单，只要保证一个Topic只有一个客户端订阅即可。例如我们用以下规则组合Topic：/user/uesrId。

  • 账号、密码，连接服务端的账号和密码，一般服务端会开启账号、密码验证才允许连接，所以代码中必须保证账号、密码正确性。

类结构

  • MqttApi：提供给外部的Api接口
  • MqttImpl：实现了MqttApi的类，为接口功能的实现。
  • MqttProxy：一个实现了MqttApi接口的代理类，它的存在是为了后续调用时做一些参数校验和拦截，还可以对Api做装饰器拓展，暂时它是转调所有Api到MqttImpl实现类。
  • MqttMessage：消息实体，内部封装Topic主题和接收到的消息字符串。
  • MqttOption：MQTT连接的配置类，采用Builder模式实现参数配置链式调用。
  • MqttQos：Mqtt消息质量枚举（对于上面3种质量）
  • NetworkUtil：网络连接工具类，用于断线重试时，避免断网了，不断重试调用MQTTClient的连接方法，不断报错，可能会大量耗电，是一种优化。
  • MessagePublishStatus：发送消息发送状态模型，用于RxJava订阅发送状态时转发使用的Model实体类。
  • ConnectionStatus：连接状态模型，用于RxJava订阅连接状态时转发使用的Model实体类。
  • MqttImproperCloseException，自定义异常类，用于RxJava的Retry操作符时，手动抛出异常，让retry操作符生效，重走连接逻辑。

代码时间

MqttImpl的代码较多，我们最后逐个讲解~

  • MqttApi：提供给外部的Api接口，有以下定义：

    1. connectServer()：连接服务器
    2. disconnectServer()：断开连接
    3. restartConnectServer()：重启连接
    4. publishMessage()：发布消息
    5. subscribeMessage()：监听消息接收
    6. subscribeConnectionStatus()：订阅连接状态
    7. subscribeMessagePublishStatus()：订阅消息发送状态
    8. subscribeTopic()：动态订阅一个主题
    9. unsubscribeTopic()：动态取消订阅一个主题
public interface MqttApi {
    /**
     * 连接服务器
     *
     * @param option 配置
     */
    Observable connectServer(MqttOption option);

    /**
     * 断开连接
     */
    Observable disconnectServer();

    /**
     * 重启连接
     */
    Observable restartConnectServer();

    /**
     * 发布消息
     *
     * @param topic   主题
     * @param message 消息文本
     */
    Observable publishMessage(String topic, String message);

    /**
     * 监听消息接收
     */
    Observable subscribeMessage();

    /**
     * 订阅连接状态
     */
    Observable subscribeConnectionStatus();

    /**
     * 订阅消息发送状态
     */
    Observable subscribeMessagePublishStatus();

    /**
     * 动态订阅一个主题
     *
     * @param topic 主题
     */
    Observable subscribeTopic(String... topic);

    /**
     * 动态取消订阅一个主题
     *
     * @param topic 主题
     */
    Observable unsubscribeTopic(String... topic);
}
  • MqttProxy：一个实现了MqttApi接口的代理类，为一个单例类，它的存在是为了后续调用时做一些参数校验和拦截，还可以对Api做装饰器拓展，暂时它是转调所有Api到MqttImpl实现类。
public class MqttProxy implements MqttApi {
    private final MqttApi mImpl;

    private MqttProxy() {
        mImpl = new MqttImpl(ContextProvider.get().getContext());
    }

    private static final class SingleHolder {
        private static final MqttProxy INSTANCE = new MqttProxy();
    }

    public static MqttProxy getInstance() {
        return SingleHolder.INSTANCE;
    }

    @Override
    public Observable connectServer(MqttOption option) {
        return mImpl.connectServer(option);
    }

    @Override
    public Observable disconnectServer() {
        return mImpl.disconnectServer();
    }
    
    //...省略其他方法的转调代码
}

  • MqttMessage：消息实体，内部封装Topic主题和接收到的消息字符串。有2个字段：

    1. topic，本次消息来自的主题Topic
    2. message，本次消息内容字符串，不限定内容，一般为json
public class MqttMessage {
    /**
     * 订阅的主题
     */
    private String topic;
    /**
     * 接收到的消息
     */
    private String message;

    public MqttMessage(String topic, String message) {
        this.topic = topic;
        this.message = message;
    }

    //...省略get、set方法
}

  • MqttOption：MQTT连接的配置类，采用Builder模式实现参数配置链式调用。有以下参数可配置：

    1. serverUrl：服务连接
    2. username：用户名（账号）
    3. passWord：密码
    4. clientId：客户端唯一Id
    5. topics：需要订阅的主题
    6. retryIntervalTime：重试间隔时间，单位为秒，默认为2秒，不能小于等于0
    7. connectionTimeout：连接超时时间，单位为秒，默认为10秒，不能小于等于0
    8. keepAliveInterval：心跳间隔时间，单位为秒，默认为30秒，不能小于等于0
public class MqttOption {
    private String serverUrl;
    private String username;
    private String passWord;
    private String clientId;
    private String[] topics;
    private int retryIntervalTime;
    private int connectionTimeout;
    private int keepAliveInterval;

    private MqttOption(Builder builder) {
        this.serverUrl = builder.serverUrl;
        this.username = builder.username;
        this.passWord = builder.passWord;
        this.clientId = builder.clientId;
        this.topics = builder.topics == null ? new String[0] : builder.topics;
        this.retryIntervalTime = builder.retryIntervalTime == 0 ? 2 : builder.retryIntervalTime;
        this.connectionTimeout = builder.connectionTimeout <= 0 ? 10 : builder.connectionTimeout;
        this.keepAliveInterval = builder.keepAliveInterval <= 0 ? 30 : builder.keepAliveInterval;
    }

    public String getServerUrl() {
        return serverUrl;
    }

    public String getUsername() {
        return username;
    }

    public String getPassWord() {
        return passWord;
    }
    
    //...省略其他参数的get方法

    public static class Builder {
        /**
         * 服务端地址
         */
        private String serverUrl;
        /**
         * 账号
         */
        private String username;
        /**
         * 密码
         */
        private String passWord;
        /**
         * 客户端Id，必须唯一
         */
        private String clientId;
        /**
         * 需要订阅的主题，连接成功后，会自动订阅
         */
        private String[] topics;
        /**
         * 重试间隔时间，单位为秒
         */
        private int retryIntervalTime;
        /**
         * 连接超时时间
         */
        private int connectionTimeout;
        /**
         * 保持活动时间，超过时间没有消息收发将会触发ping消息确认
         */
        private int keepAliveInterval;

        public Builder setServerUrl(String serverUrl) {
            this.serverUrl = serverUrl;
            return this;
        }

        public Builder setUsername(String username) {
            this.username = username;
            return this;
        }

        //...省略其他参数的set方法

        public MqttOption build() {
            return new MqttOption(this);
        }
    }
}

  • MqttQos：Mqtt消息质量枚举（对于上面3种质量）

    1. MOST_ONCE：值为0，最多一次，有可能重复或丢失
    2. LEAST_ONE：值为1，至少一次，有可能重复
    3. ONLY_ONE：值为2，只有一次，确保消息只到达一次（用于比较严格的计费系统）
public enum MqttQos {
    /**
     * 最多一次，有可能重复或丢失
     */
    MOST_ONCE(0),
    /**
     * 至少一次，有可能重复
     */
    LEAST_ONE(1),
    /**
     * 只有一次，确保消息只到达一次（用于比较严格的计费系统）
     */
    ONLY_ONE(2);

    private int mCode;

    MqttQos(int code) {
        mCode = code;
    }

    public int getCode() {
        return mCode;
    }
}
  • NetworkUtil：网络连接工具类，用于断线重试时，避免断网了，不断重试调用MQTTClient的连接方法，不断报错，可能会大量耗电，是一种优化。
public class NetworkUtil {
    private NetworkUtil() {
    }

    /**
     * 当前是否有网络状态
     *
     * @param context  上下文
     * @param needWifi 是否只有连接上wifi才算是连接上网络
     */
    public static boolean hasNetWorkStatus(Context context, boolean needWifi) {
        NetworkInfo info = getActiveNetwork(context);
        if (info == null) {
            return false;
        }
        if (!needWifi) {
            return info.isAvailable();
        } else if (info.getType() == ConnectivityManager.TYPE_WIFI) {
            return info.isAvailable();
        }
        return false;
    }

    /**
     * 获取活动网络连接信息
     *
     * @param context 上下文
     * @return NetworkInfo
     */
    public static NetworkInfo getActiveNetwork(Context context) {
        ConnectivityManager mConnMgr = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        if (mConnMgr == null) {
            return null;
        }
        // 获取活动网络连接信息
        return mConnMgr.getActiveNetworkInfo();
    }
}

  • MessagePublishStatus：发送消息发送状态模型，用于RxJava订阅发送状态时转发使用的Model实体类。有2个字段：

    1. isComplete：表示是否发送完毕
    2. message：发送的消息内容
public class MessagePublishStatus {
    /**
     * 是否发送完毕
     */
    private boolean isComplete;
    /**
     * 发送的消息内容
     */
    private String message;

    public MessagePublishStatus(boolean isComplete, String message) {
        this.isComplete = isComplete;
        this.message = message;
    }
    
    //省略get、set方法
}

  • ConnectionStatus：连接状态模型，用于RxJava订阅连接状态时转发使用的Model实体类。有3个字段：

    1. isLost：表示是否丢失连接
    2. isRetry：是否正在重新连接
    3. error：丢失连接时的异常
public class ConnectionStatus {
    /**
     * 是否丢失连接
     */
    private boolean isLost;
    /**
     * 是否在重新连接
     */
    private boolean isRetry;
    /**
     * 丢失连接时的异常
     */
    private Throwable error;

    public ConnectionStatus(boolean isLost, Throwable error) {
        this.isLost = isLost;
        this.error = error;
    }

    public ConnectionStatus(boolean isRetry) {
        this.isRetry = isRetry;
    }

    //省略get、set方法
}
  • MqttImproperCloseException，自定义异常类，用于RxJava的Retry操作符时，手动抛出异常，让retry操作符生效，重走连接逻辑。
public class MqttImproperCloseException extends Exception {
    private static final long serialVersionUID = -4030414538155742302L;

    MqttImproperCloseException() {
    }

    public MqttImproperCloseException(String message) {
        super(message);
    }
}
  • MqttImpl：实现了MqttApi的类，为接口功能的实现。
  1. 构造方法初始化，保存Context上下文。创建MqttAndroidClient时需要用到。
public class MqttImpl implements MqttApi {
    /**
     * 上下文
     */
    private Context mContext;

    MqttImpl(Context context) {
        mContext = context.getApplicationContext();
    }
}
  1. 开启连接。

将传入的MqttOption配置转换为MQTT库提供的MqttConnectOptions配置对象并配置相关参数。创建一个MqttAndroidClient客户端，注意ClientId需要加上随机数保证多个账号在不同客户端中登录时，不会Id相同导致互抢连接。

因为连接可能会失败，所以加入了RxJava的retry()操作符，在连接失败时，手动Observable.error()抛出一个MqttImproperCloseException自定义异常，让retry操作符生效，再使用Observable.timer()操作符延时配置的重试间隔时间后重走可观察者的订阅方法进行重连。

由于很多情况都是手机网络不好或手动切换网络时，断开了MQTT的连接，所以加入了NetworkUtil工具类，检查当前网络情况，如果网络被关闭，则手动发送onNext(false)，继续重走重试逻辑，避免不断地重试，调用MqttClient的connect()连接方法，不断的连接失败。

/**
 * 当前引用的配置
 */
private MqttOption mCurrentApplyOption;
/**
 * Mqtt客户端
 */
private MqttAndroidClient mMqttClient;
/**
 * 是否已连接
 */
private boolean isConnect;

@Override
public Observable connectServer(MqttOption option) {
    mCurrentApplyOption = option;
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            if (mMqttClient == null) {
                mMqttClient = new MqttAndroidClient(
                        mContext,
                        option.getServerUrl(),
                        option.getClientId(),
                        new MemoryPersistence());
            }
            if (isConnect) {
                emitter.onNext(true);
                return;
            }
            //如果没有网络，不开启连接
            if (!NetworkUtil.hasNetWorkStatus(mContext, false)) {
                emitter.onNext(false);
                return;
            }
            //进行链接配置
            MqttConnectOptions connectOptions = new MqttConnectOptions();
            //如果为false(flag=0)，Client断开连接后，Server应该保存Client的订阅信息
            //如果为true(flag=1)，表示Server应该立刻丢弃任何会话状态信息
            connectOptions.setCleanSession(true);
            //设置用户名和密码
            connectOptions.setUserName(option.getUsername());
            connectOptions.setPassword(option.getPassWord().toCharArray());
            //设置连接超时时间
            connectOptions.setConnectionTimeout(option.getConnectionTimeout());
            //设置心跳发送间隔时间，单位秒
            connectOptions.setKeepAliveInterval(option.getKeepAliveInterval());
            //设置遗嘱
            connectOptions.setWill("android-mqtt-offline-topic", "android-mqtt-is_offline".getBytes(), MqttQos.ONLY_ONE.getCode(), false);
            //开始连接
            mMqttClient.connect(connectOptions, null, new IMqttActionListener() {
                @Override
                public void onSuccess(IMqttToken asyncActionToken) {
                    emitter.onNext(true);
                }

                @Override
                public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                    exception.printStackTrace();
                    emitter.onNext(false);
                }
            });
        }
    }).flatMap(new Function>() {
        @Override
        public ObservableSource apply(Boolean isSuccess) throws Exception {
            //连接成功，
            if (isSuccess) {
                return subscribeTopic(mCurrentApplyOption.getTopics());
            } else {
                //连接失败，重试
                return Observable.error(new MqttImproperCloseException());
            }
        }
    }).doOnNext(new Consumer() {
        @Override
        public void accept(Boolean isSuccess) throws Exception {
            isConnect = isSuccess;
        }
    }).retryWhen(new Function, ObservableSource>() {
        @Override
        public ObservableSource apply(Observable throwableObservable) throws Exception {
            return throwableObservable.flatMap(new Function>() {
                @Override
                public ObservableSource apply(Throwable throwable) throws Exception {
                    mMqttClient = null;
                    //所有异常都走重试，延时指定秒值进行重试
                    return Observable.timer(mCurrentApplyOption.getRetryIntervalTime(), TimeUnit.SECONDS)
                            .doOnNext(new Consumer() {
                                @Override
                                public void accept(Long aLong) throws Exception {
                                    if (mConnectionStatusListener != null) {
                                        mConnectionStatusListener.onRetryConnection();
                                    }
                                }
                            });
                }
            });
        }
    });
}
  1. 断开连接，将当前的链接断开，如果已经断开了，则不执行断开操作。
@Override
public Observable disconnectServer() {
    //已经断开连接了
    if (!isConnect) {
        return Observable.just(true);
    }
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            try {
                mMqttClient.disconnect(null, new IMqttActionListener() {
                    @Override
                    public void onSuccess(IMqttToken asyncActionToken) {
                        mMqttClient = null;
                        emitter.onNext(true);
                    }

                    @Override
                    public void onFailure(IMqttToken asyncActionToken, Throwable exception) {
                        exception.printStackTrace();
                        emitter.onNext(false);
                    }
                });
            } catch (MqttException e) {
                e.printStackTrace();
                emitter.onNext(false);
            }
        }
    }).doOnNext(new Consumer() {
        @Override
        public void accept(Boolean isSuccess) throws Exception {
            isConnect = !isSuccess;
        }
    });
}
  1. 重新连接，就是先断开连接，再调用连接。
@Override
public Observable restartConnectServer() {
    //先断开，再重新连接
    return disconnectServer().flatMap(new Function>() {
        @Override
        public ObservableSource apply(Boolean isSuccess) throws Exception {
            if (isSuccess) {
                return connectServer(mCurrentApplyOption);
            }
            return Observable.just(false);
        }
    });
}
  1. 发布消息，对特定Topic主题，发布消息。消息质量为MqttQos.ONLY_ONE，只有一次，确保消息只到达一次（用于比较严格的计费系统）
@Override
public Observable publishMessage(String topic, String message) {
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            //连接未打开
            if (!isConnect) {
                emitter.onNext(false);
            }
            try {
                //发布消息
                mMqttClient.publish(topic, message.getBytes(), MqttQos.ONLY_ONE.getCode(), false);
                emitter.onNext(true);
            } catch (MqttException e) {
                e.printStackTrace();
                emitter.onNext(false);
            }
        }
    });
}
  1. 订阅消息，订阅回调对象为MqttMessage，MqttMessage中有消息的Topic主题和消息内容。
@Override
public Observable subscribeMessage() {
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            mMqttClient.setCallback(new MqttCallback() {
                @Override
                public void connectionLost(Throwable cause) {
                    //与服务器之间的连接失效
                    isConnect = false;
                    if (mConnectionStatusListener != null) {
                        mConnectionStatusListener.onConnectionLost(cause);
                    }
                    emitter.onError(cause);
                }

                @Override
                public void messageArrived(String topic, org.eclipse.paho.client.mqttv3.MqttMessage message) throws Exception {
                    //接收到消息
                    emitter.onNext(new MqttMessage(topic, message.toString()));
                }

                @Override
                public void deliveryComplete(IMqttDeliveryToken token) {
                    //发送完成
                    if (mMessagePublishStatusListener != null) {
                        try {
                            String message = token.getMessage().toString();
                            mMessagePublishStatusListener.onMessagePublishComplete(message);
                        } catch (MqttException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }).retryWhen(new Function, ObservableSource>() {
        @Override
        public ObservableSource apply(Observable throwableObservable) throws Exception {
            return throwableObservable.flatMap(new Function>() {
                @Override
                public ObservableSource apply(Throwable throwable) throws Exception {
                    //延时重连
                    return Observable.timer(mCurrentApplyOption.getRetryIntervalTime(), TimeUnit.SECONDS).flatMap(new Function>() {
                        @Override
                        public ObservableSource apply(Long aLong) throws Exception {
                            return connectServer(mCurrentApplyOption);
                        }
                    });
                }
            });
        }
    });
}
  1. 订阅连接状态，有2种情况，连接丢失和重连时的回调。
/**
 * 连接状态监听
 */
private OnConnectionStatusListener mConnectionStatusListener;

/**
 * 连接状态监听
 */
public interface OnConnectionStatusListener {
    /**
     * 连接丢失
     *
     * @param error 异常对象
     */
    void onConnectionLost(Throwable error);

    /**
     * 正在重试连接
     */
    void onRetryConnection();
}

private void setOnConnectionStatusListener(OnConnectionStatusListener connectionStatusListener) {
    mConnectionStatusListener = connectionStatusListener;
}

@Override
public Observable subscribeConnectionStatus() {
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            setOnConnectionStatusListener(new OnConnectionStatusListener() {
                @Override
                public void onConnectionLost(Throwable error) {
                    emitter.onNext(new ConnectionStatus(true, error));
                }

                @Override
                public void onRetryConnection() {
                    emitter.onNext(new ConnectionStatus(true));
                }
            });
        }
    });
}
  1. 订阅消息发送状态，暂时只有一个发送成功后的状态回调。
/**
 * 消息发布状态监听器
 */
private OnMessagePublishStatusListener mMessagePublishStatusListener;

/**
 * 消息发送状态监听
 */
public interface OnMessagePublishStatusListener {
    /**
     * 发送消息完成
     *
     * @param message 原始消息
     */
    void onMessagePublishComplete(String message);
}

private void setOnMessagePublishStatusListener(OnMessagePublishStatusListener messagePublishStatusListener) {
    mMessagePublishStatusListener = messagePublishStatusListener;
}

@Override
public Observable subscribeMessagePublishStatus() {
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            setOnMessagePublishStatusListener((message)
                    -> emitter.onNext(new MessagePublishStatus(true, message)));
        }
    });
}
  1. 订阅主题，传入需要订阅的多个主题的数组即可。消息质量，我这里固定为MqttQos.ONLY_ONE，就是只有一次，确保消息只到达一次。有需要可以自行修改。
@Override
public Observable subscribeTopic(String... topic) {
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            if (topic.length == 0) {
                emitter.onNext(true);
                return;
            }
            try {
                int size = topic.length;
                int[] qosArr = new int[size];
                for (int i = 0; i < size; i++) {
                    qosArr[i] = MqttQos.ONLY_ONE.getCode();
                }
                mMqttClient.subscribe(topic, qosArr);
                emitter.onNext(true);
            } catch (MqttException e) {
                e.printStackTrace();
                emitter.onNext(false);
            }
        }
    });
}
  1. 取消订阅主题，传入需要取消订阅的Topic数组即可。
@Override
public Observable unsubscribeTopic(String... topic) {
    return Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            try {
                mMqttClient.unsubscribe(topic);
                emitter.onNext(true);
            } catch (MqttException e) {
                e.printStackTrace();
                emitter.onNext(false);
            }
        }
    });
}

使用

我们新建一个Service，例如通知模块的MqttService，名为NoticeMqttService。在onStartCommand()方法回调时，使用MqttProxy类进行连接。后续则是消息接收订阅、连接状态订阅、发送状态订阅。最后是发送消息。

class NoticeMqttService : Service() {
    private val mDisposables: CompositeDisposable = CompositeDisposable()

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        connectMqttService()
        return super.onStartCommand(intent, flags, startId)
    }

    override fun onDestroy() {
        super.onDestroy()
        if (!mDisposables.isDisposed) {
            mDisposables.clear()
        }
    }

    /**
     * 连接服务端Mqtt
     */
    private fun connectMqttService() {
        val userId = "10086"
        mDisposables.apply {
            MqttProxy.getInstance().apply {
                val topic = "/user/${userId}"
                //连接服务
                add(
                    connectServer(
                        MqttOption.Builder()
                            .setServerUrl("tcp://192.168.0.211:1883")
                            .setUsername("admin")
                            .setPassWord("admin")
                            .setClientId(userId)
                            .setTopics(mutableListOf(topic).toTypedArray())
                            .build()
                    ).ioToMain().subscribe({ isConnectSuccess ->
                        Logger.d("Mqtt连接是否成功: $isConnectSuccess")
                    }, { error ->
                        error.printStackTrace()
                        Logger.d("Mqtt连接失败，原因: ${error.message}")
                    })
                )
                //订阅消息接收
                add(
                    subscribeMessage()
                        .ioToMain()
                        .subscribe({ mqttMessage ->
                            val msg = "Mqtt收到消息: ${mqttMessage.message}"
                            //一般会在这里解析Json，并进行数据、UI处理
                            Logger.d(msg)
                        }, { error ->
                            error.printStackTrace()
                            Logger.d("Mqtt收到消息，但是抛出异常，原因: ${error.message}")
                        })
                )
                //订阅连接状态
                add(
                    subscribeConnectionStatus()
                        .ioToMain()
                        .subscribe({ status ->
                            if (status.isLost) {
                                Logger.d("Mqtt连接丢失，原因: ${status.error.message}")
                            } else if (status.isRetry) {
                                Logger.d("Mqtt重试连接中...")
                            }
                        }, { error ->
                            error.printStackTrace()
                        })
                )
                //订阅消息发送状态
                add(
                    subscribeMessagePublishStatus()
                        .ioToMain()
                        .subscribe({ status ->
                            if (status.isComplete) {
                                Logger.d("Mqtt消息发送完毕，消息内容: ${status.message}")
                            }
                        }, { error ->
                            error.printStackTrace()
                        })
                )
                //发送消息
                val msg = "我是测试消息"
                add(
                    publishMessage(topic, msg)
                        .subscribe({ result ->
                            Logger.d("Mqtt发送消息是否成功: $result")
                        }, { error ->
                            error.printStackTrace()
                            Logger.d("Mqtt发送消息失败，消息Topic${topic}, 消息内容: ${msg}")
                        })
                )
            }
        }
    }

    override fun onBind(intent: Intent?): IBinder? {
        return Binder()
    }
}

最后在清单文件中，配置Service

总结

MQTT内容并不是太多，一般只有一个连接，如果不同模块需要不同的消息源，订阅不同的Topic主题即可。

你可能感兴趣的:(MQTT、RxJava封装)

  • webpack图片等资源的处理 dmengmeng
    需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片 诚芯微科技 社交电子
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信 z755924843 ESP32开发快速入门服务器网络运维
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • Python 推导式(Comprehensions) 戒灵
    1,列表推导式num=[1,2,-5,10,-7,5,7,-1]filtered_and_squared=[x**2forxinnumifx>0]print(filtered_and_squared)迭代器(iterator)遍历输入序列num的每个成员x断言式判断每个成员是否大于零如果成员大于零，则被交给输出表达式，平方之后成为输出列表的成员。列表推导式被封装在一个列表中，所以很明显它能够立即生
  • HarmonyOS Next鸿蒙扫一扫功能实现 JohnLiu_ HarmonyOSNextharmonyos华为扫一扫鸿蒙
    直接使用的是华为官方提供的api，封装成一个工具类方便调用。import{common}from'@kit.AbilityKit';import{scanBarcode,scanCore}from'@kit.ScanKit';exportnamespaceScanUtil{exportasyncfunctionstartScan(context:common.Context):Promise{if
  • Java【泛型】 SkyrimCitadelValinor Java基础java
    Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • 【C#Mutex】 initiallyOwned错误引起的缺陷 闻缺陷则喜何志丹 c#互斥量进程同步WaitOneinitiallyOwned临界区
    临界区只能对同一个进程的不同线程同步，互斥量可以跨进程同步。典型应用场景：两个exe会操作同一个注册表项。错误代码封装类publicclassCMutexHelp:IDisposable{publicCMutexHelp(){s_mutex.WaitOne();}privatestaticMutexs_mutex=newMutex(true,"Time202409091406ab");public
  • 上传文件到钉盘流程详解 jspyth 开发场景案例分析开发语言java后端
    文章目录前言准备工作实现过程Maven依赖封装一个工具类获取文件上传信息unionId获取钉盘目录spaceId创建上传到钉盘前言  本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。准备工作1、在钉钉开发者后台创建一个钉钉企业内部应用；2、创建并保存好应用的appKey和appSecret，后面用于获取调用API的请求token；3、应用中配置好所需权限：企业存储文件上传
  • axios 请求封装 web Rookie 工作前端javascriptajax
    文章目录1.前言2.axios下载3.代码实现4.实际使用1.前言本文是对于axios的二次封装处理，axios是一个基于Promise的网络请求库，作用于node.js和浏览器中；本文对于axios中的封装着重于直接使用，如果想要学习axios相关知识可以先行离开，后续在对其进行完善2.axios下载npminstallaxios3.代码实现//request.tsimportaxios,{Ax
  • 【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信 月夜星辉雪 rabbitmq网络分布式c++后端服务器linux
    一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
  • Open Feign 实战笔记 自强-X spring-cloudjavaspring微服务ribbonspringcloud
    OpenFeign笔记概念声明式的web服务客户端。使用接口加注解的形式编程。它是对RestTemplate和ribbon做了进一步封装。Feign已经停更，OpenFeign是在Feign的基础上又做了进一步的封装。Feign：Feign是SpringCloud组件中的一个轻量级RESTful的HTTP服务客户端Feign内置了Ribbon，用来做客户端负载均衡，去调用服务注册中心的服务。Fei
  • AI教你学Python 第5天：面向对象编程（OOP）基础 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第5天：面向对象编程（OOP）基础一、面向对象编程概述面向对象编程（OOP）是一种编程范式，使用“对象”来表示数据和数据上可用的操作。OOP的核心概念包括类、对象、继承、多态和封装。概念描述类一种蓝图，定义了对象的属性和方法。对象类的实例，包含具体的数据和方法。继承一个类可以继承另一个类的属性和方法，从而实现代码重用。多态同一操作作用于不同对象时，表现出不同的行为。封装把数据和操作数据的方法绑定在
  • quartus pin 分配（三） 落雨无风 IC设计fpgafpga开发
    quartuspin分配如有需要，可查看quartusUI界面sdc配置（二）上次文章中，说了自己写sdc需要配置的分类点，这次将介绍管脚分配。已打开Quartus软件，导入设计，写好约束下一步，在Quartus软件的菜单栏打开Assignments中的二级菜单PinPlanner打开改界面即可看到选中的fpga型号，管脚图，封装类型等信息。在打开的界面中，大致可分为上下两个部分。上半部分，可分为
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用 erhtre 程序员androidjetpack架构sqlite
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
  • 麻雀虽小，五脏俱全 - Java工具类库 - Hutool waiter_chen
    Hutool官网：https://www.hutool.cn官方参考文档：https://www.hutool.cn/docsAsetoftoolsthatkeepJavasweet.——Htool特点通过静态方法封装，类函数式语言般，降低学习成本，提高工作效率整合多方用户需求，减少代码搜索成本，避免网络上参差不齐的代码出现导致的bugutil包提供多方公用类和公用工具方法，节省开发封装时间，减少
  • react里的index.js是怎么跟index.html结合起来的? SherrinfordL
    image.pngcreate-react-app把webpack、babel等配置都封装到了依赖项目react-script中，所以你无法直观的看到这些配置。你可以在项目下运行npmruneject，被隐藏的配置文件就会暴露到项目根路径下。把请求转发到index.html原因是，你执行npmrunstart时，启动的webpack-dev-server，会加载react-script项目conf
  • 网上商城项目总结报告 WEB前端程序贵 前端
    网上商城项目总结报告1：掌握的知识通过网上商城这个实战项目的开发，不仅了解到了一个项目的业务逻辑，而且掌握了实现相关业务功能的方法。通过这个实战项目，了解到了模块化开发项目的基础结构的搭建，以及项目文件的管理方式。通过这个实战项目，运用封装的接口api文档实现了客户端服务器之间的交互知识。通过封装的axios实例对象与方法，向服务器请求数据，然后渲染页面。通过运用localStorage本地储存的
  • 笔记：JAVA面向对象三大特征——封装继承多态 听原来是雨落 Javajava开发语言后端
    高内聚，低耦合：  高内聚：类的内部数据操作细节自己完成，不允许外部干涉；    低耦合：仅暴露少量的方法给外部使用。一、封装：  含义：1.指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个密不可分的独立单位（即对象）中；     2.指“信息隐藏”，把不需要外界知道的信息隐藏起来，有些对象的属性及行为为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，
  • 【JavaSE】封装、继承与多态 泡芙冰淇淋ya JavaSEjava开发语言
    1、封装1.1简介在Javase中，封装（Encapsulation）是面向对象编程（OOP）的一个重要概念。封装的主要目的是隐藏对象的内部状态和信息，只提供必要的公共方法来访问和操作这些状态和信息。通过封装可以控制对对象内部数据的访问级别，并保护数据不被随意修改，从而提高代码的安全性和可维护性。1.2特点信息隐藏：对象的内部状态（即属性或数据成员）被隐藏起来，外部世界只能通过对象提供的方法来访问
  • 面向对象编程03：封装、继承、多态 Clap of thunder Java从零学起java封装多态继承面向对象编程
    面向对象编程03：封装、继承、多态文章目录面向对象编程03：封装、继承、多态封装继承object类supersuper注意点：`super`VS`this`:方法重写多态多态的注意事项：instanceof关键字父类与子类之间的类型转换封装该露的露、该藏的藏设计程序要追求“高内聚、低耦合”。高内聚就是类的内部数据操作细节由自己完成，不允许外部干涉；低耦合：仅仅暴露少量的方法给外部使用。封装（数据的
  • java 什么是多态性_Java多态性理解 职路施语 java什么是多态性
    什么是多态面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)实现多态的技术称为：动态绑定(dynamicbinding)，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应
  • 计算PCB设计中SMD焊盘尺寸的最佳方法 David WangYang 硬件工程
    SMD元件需要精确尺寸的焊盘以便在组装过程中进行焊接。PCB设计师仍然需要使用数据表中的信息以及通用的焊盘和焊地尺寸公式来创建许多自己的封装。设计师负责确保焊盘尺寸正确，要么通过计算并与封装数据进行比较，查阅数据表，要么通过记住SMD焊盘尺寸标准。如果你有一个元件，但你没有访问到封装，而你决定自己构建封装，有哪些资源可以确保你拥有正确的焊盘尺寸？计算SMD焊盘尺寸对于SMD组件，确定焊盘尺寸有几种
  • Vue3项目开发——新闻发布管理系统（六） bjzhang75 Vue知识学习及项目开发实践Vue3项目开发新闻发布管理系统
    文章目录八、首页设计开发1、页面设计2、登录访问拦截实现3、用户基本信息显示①封装用户基本信息获取接口②用户基本信息存储③用户基本信息调用④用户基本信息动态渲染4、退出功能实现①注册点击事件②添加退出功能③数据清理5、代码下载八、首页设计开发登录成功后，系统就进入了首页。接下来，也就进行首页的开发了。1、页面设计系统页面主要分为三部分，左侧为系统的菜单栏，右侧上部为系统的头部，下部为系统的主体区域
  • C++快速入门扫盲总结 六竹书生__wa C/C++Qt
    C++快速入门扫盲总结C++语言新特性C++的新特性C++的输入输出方式C++之命名空间namespaceC++面向对象类和对象构造函数与析构函数this指针继承重载函数重载运算符重载多态数据封装数据抽象接口（抽象类）C++语言新特性C++的新特性C++比C语言新增的数据类型是布尔类型（bool）。但是在新的C语言标准里已经有布尔类型了，但是在旧的C语言标准里是没有布尔类型的，编译器也无法解释布尔
  • 类与对象（上） zkydxj c++
    目录一、认识面向过程与面向对象二、类的引入三、类的定义1、类有两种定义方式：1.定义与声明全部放在类体中。2.类声明在.h文件中，成员函数定义在.cpp文件中。2、成员变量命名规则的建议四、类的访问限定符与封装1.封装2.访问限定符五、类的实例化一、认识面向过程与面向对象我们之前学过的c语言是一种面向过程的语言，面向过程指代码关注的是过程，分析求解解决问题的步骤，通过函数调用逐步解决问题。而c++
  • 每天五分钟玩转深度学习PyTorch：模型参数优化器torch.optim 幻风_huanfeng 深度学习框架pytorch深度学习pytorch人工智能神经网络机器学习优化算法
    本文重点在机器学习或者深度学习中，我们需要通过修改参数使得损失函数最小化(或最大化)，优化算法就是一种调整模型参数更新的策略。在pytorch中定义了优化器optim，我们可以使用它调用封装好的优化算法，然后传递给它神经网络模型参数，就可以对模型进行优化。本文是学习第6步(优化器)，参考链接pytorch的学习路线随机梯度下降算法在深度学习和机器学习中，梯度下降算法是最常用的参数更新方法，它的公式
  • scala的option和some 矮蛋蛋 编程scala
    原文地址： http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
  • NullPointerException Cb123456 androidBaseAdapter
        java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference     出现以上异常.然后就在baidu上
  • PHP使用文件和目录 天子之骄 php文件和目录读取和写入php验证文件php锁定文件
    PHP使用文件和目录 1.使用include()包含文件 (1)：使用include()从一个被包含文档返回一个值 (2)：在控制结构中使用include()   include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。   在php.ini文件中设置
  • SQL SELECT DISTINCT 语句 何必如此 sql
    SELECT DISTINCT 语句用于返回唯一不同的值。 SQL SELECT DISTINCT 语句 在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 DISTINCT 关键词用于返回唯一不同的值。 SQL SELECT DISTINCT 语法 SELECT DISTINCT column_name,column_name F
  • java冒泡排序 3213213333332132 java冒泡排序
    package com.algorithm; /** * @Description 冒泡 * @author FuJianyong * 2015-1-22上午09:58:39 */ public class MaoPao { public static void main(String[] args) { int[] mao = {17,50,26,18,9,10
  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！ 7454103 DAOspringAjaxjsonqq
    struts2.18  出来有段时间了！ （貌似是 稳定版）   闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！   实践了下下！ 不当之处请绕过！ 呵呵   网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar   strut
  • struts2 数据标签说明 darkranger jspbeanstrutsservletScheme
    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能 数据标签主要包括： action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
  • 链表.简单的链表节点构建 aijuans 编程技巧
    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" #define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}} typedef struct node {  &nbs
  • tomcat下jndi的三种配置方式 avords tomcat
    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称 访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。          tomcat配置
  • 关于敏捷的一些想法 houxinyou 敏捷
    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 感觉表达的不太清楚。 感觉容易被人误解的地方主要在“用户多变的需求”上。 第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
  • 富养还是穷养，决定孩子的一生 bijian1013 教育人生
    是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由 事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
  • oracle 日期时间格式转化 征客丶 oracle
    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； SYSDATE：不支持毫秒，取的是系统时间； SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。 日期转字符窜： 一、不取毫秒： TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 简要说明， YYYY 年 MM   月
  • 【Scala六】分析Spark源代码总结的Scala语法四 bit1129 scala
    1. apply语法   FileShuffleBlockManager中定义的类ShuffleFileGroup，定义：   private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) { ... def apply(bucketId
  • Erlang中有意思的bug bookjovi erlang
      代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b Author: Jovi Zhang <[email protected]> Date: Fri Dec 2 16:19:22 2011 +0100 erts:
  • 移位打印10进制数转16进制-2008-08-18 ljy325 java基础
    /** * Description 移位打印10进制的16进制形式 * Creation Date 15-08-2008 9:00 * @author 卢俊宇 * @version 1.0 * */ public class PrintHex { // 备选字符 static final char di
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 利用cmd命令将.class文件打包成jar chenyu19891124 cmdjar
    cmd命令打jar是如下实现： 在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： cd D: 回车 cd workspace/prpal
  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 comsci eclipse设计模式算法工作swing
                           JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明     &nb
  • SecureCRT右键粘贴的设置 daizj secureCRT右键粘贴
    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。 老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。 菜单： Options->Global Options ...->Terminal 右边有个Mouse的选项块。 Copy on Select Paste on Right/Middle
  • Linux 软链接和硬链接 dongwei_6688 linux
    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。 【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
  • DIV底部自适应 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • Centos6.5使用yum安装mysql——快速上手必备 dcj3sjt126com mysql
    第1步、yum安装mysql [root@stonex ~]#  yum -y install mysql-server 安装结果： Installed:     mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
  • 如何调试JDK源码 frank1234 jdk
    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。 可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。 下面是编译jdk的具体步骤：         1.把C:\java\jdk1.6.0_26\sr
  • Maximal Rectangle hcx2013 max
    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.   public class Solution { public int maximalRectangle(char[][] matrix)
  • Spring MVC测试框架详解——服务端测试 jinnianshilongnian spring mvc test
    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。   Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 &nbs
  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0 liyong0802 hadoop
    一、准备编译软件   1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。     环境变量设置如下：   （1）执行vim /etc/profile （2）在文件尾部加入: export JAVA_HOME=/home/spark/jdk1.7 export MAVEN_HOME=/ho
  • StatusBar 字体白色 pangyulei status
    [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent]; /*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
  • 如何分析Java虚拟机死锁 sesame javathreadoracle虚拟机jdbc
    英文资料： Thread Dump and Concurrency Locks   Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
  • 位运算简介及实用技巧（一）：基础篇 tw_wangzhengquan 位运算
    http://www.matrix67.com/blog/archives/263    去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
  • jsearch的索引文件结构 yangshangchuan 搜索引擎jsearch全文检索信息检索word分词
    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。   jsearch的索引文件结构定义如下：     1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他