8e750c8f0fae
8e750c8f0fae

Android 抖音爆红的口红挑战爬坑总结

项目背景

今年，相信很多人都会在各个商场或者是电影院中可以看到各种娃娃机、幸运盒子、口红挑战等等类似机器。在抖音上《口红挑战》这款机子也是火的一塌糊涂，你只要花 10 块钱就有可能赢走一个 YSL 口红，想想就觉得很有诱惑力。或许这些机器被程序员一瞧就知道其中的猫腻，但是这个机器瞄准的是那些容易冲动消费的消费者，比如情侣、女生、带小孩的大人；像程序员这么奇葩的生物，一般都是直接被无视的哈哈。

然后呢，我们公司就是为这些设备的正常运行提供解决方案的。因此才有我今天的爬坑总结，哈哈哈哈哈.....

我们提供的解决方案是这样的，在一个门店里面会包含如下的设备：娃娃机、口红挑战、排行榜、中控，当然其中还有我们的后台服务。那么首先我会先介绍一下整个系统的架构以及各个设备的职责：

  • 系统架构图
门店系统结构图.png
  • 服务后台
    • 服务后台不属于 Android 这端负责的，因此不需要去关注太多，服务后台相对于门店设备而言，它的一个职责是负责给机器发送上分质量，监测设备状态，及一些其他的信息。
  • 中控（本地服务：不连接外网）：这个中控也是也 Android 设备，它的功能有两个：
    1. 排行榜：用来接收娃娃机中发送过来的用户夹中娃娃的信息，并最后将其显示在排行榜上。
    2. 资源分发中控：作为资源的分发中心，中控需要分发 apk 安装包、图片、
  • 娃娃机：这一块其实包含了两个部分，一个是 Android 设备，另外一个硬件设备。
    1. Android 设备主要是用来显示 banner、处理服务器数据（例如：上分）、对接中控（资源更新、数据反馈等）、对接硬件设备
    2. 硬件设备主要是处理用户上分、出礼、心跳等信息，并将这些信息交给 Android 设备处理。
  • 口红挑战：关于口红挑战这个设备可以划分为 3 个模块，分别为见缝插针游戏、常规程序模块、硬件模块
    1. 关于见缝插针的这个游戏是用白鹭引擎做的，最后以 h5 的形式嵌入到 APP 中，主要负责游戏的主逻辑以及和程序主模块进行游戏逻辑数据的反馈。
    2. 常规模块主要是有处理服务后台的数据、对接硬件模块（格子选中、打开格子等）、对接游戏（启动游戏、游戏结果反馈等）、物料后台管理。
  • rocket：这个程序有点特殊，因为用户是看不到它的，在出厂的时候，这个程序就被写进去了，那么它负责的工作如下：
    1. 屏蔽设备的 systemui 程序和 launcher 程序，防止用户做一些非法的操作。
    2. 检测 U 盘是否插入，然后移动或者负责制定文件（apk 安装包、ipconfig.json 文件、三元组配资文件config.json、h5 资源文件等）
    3. 接收广播，自动安装或者更新娃娃机或者口红挑战程序

要解决的问题

同步加载资源

关于资源同步的，首先我们先理一下我们需要同步的资源有哪些，这些资源分别为： apk 安装包、图片、h5 相关的 index 资源。

资源更新的方式

关于更新的方式，这里其实就有一个比较坑的地方了，一开始的时候我们选择的资源更新方式比较傻，直接使用 websocket 进行资源更新的，一开始的时候只有一个设备进行连接，问题倒是不大，但是后来发现多台设备连接同时更新资源的时候问题特别大，连接经常断开，导致资源更新失败。那么这里是我遇到的第一个坑。发现这个坑之后呢，我的选择资源更新的方式就更改为：NanoHttpd。NanoHttpd 是一个开源库，是用 Java 实现的，它可以在 Android 设备上建立一个轻量级的 web server。其实在 Android 设备上创建一个轻量级的 web server 才是我们一开始就应该要选择的方向。为什么呢？首先 NanoHttpd 的使用是比较简单的，因此我们只需要几行代码就可以实现一个 web server 了；其次呢，NanoHttpd 是比较稳定的，相对于我们手动使用 websocket 去实现一个资源分发要稳定太多了。

那么在我们选择了资源的更新方式之后，有另外一个问题浮出水面了，关于服务器的 IP 地址。我们都知道，关于 Android 设备连接上移动互联网或者 WiFi 的时候都会被自动分配一个 IP 地址，因此这个 IP 地址是会变化的，我们的设备在每天晚上都会关机，然后在第二天开启重启的时候又会被分配到一个新的 IP 地址，因此服务器的 IP 地址是一直在变化的，所以这里我们需要做的是想办法把某个设备的 IP 地址给固定下来。那么接下来就来讲讲关于 NanoHttpd 创建轻量级的 web server 和如何解决 IP 变化的问题。

NanoHttpd 实现 web server

  • NanoHttpd 项目地址
    • https://github.com/NanoHttpd/nanohttpd
  • gradle 依赖
    implementation 'org.nanohttpd:nanohttpd-webserver:2.3.1'
  • 实现方式
    File resourceDir = new File(Environment.getExternalStorageDirectory(), "myRootDir");
    SimpleWebServer httpServer = new SimpleWebServer(null, 18103, resourceDir, true, "*");
    httpServer.start(NanoHTTPD.SOCKET_READ_TIMEOUT, true);
  • SimpleWebServer 构造函数的参数
    • host：服务器 ip 地址
    • port：端口号（取值范围：1024~65535）
    • wwwroot：放置静态资源的根目录
    • quiet：是否为安静模式
    • cors：
  • 访问方式
    • 在同个局域网下，那么我们在浏览器中输入地址：http://10.0.0.34:18103，我们就可以访问到我们服务器中的资源了，当然目前实现的服务器是静态的，只能处理 get 资源请求，不能够处理 post、put 等其他请求，目前是处理不了的，如果需要自己再处理 post 和 put 等其他的请求的话，那么可以自己去 项目原地址 中参考它的用法去实现，在这里就不多讲了。

解决 IP 变化的问题

在 Android 设备中，它的一个 IP 地址是会变化的，而且每个门店都会有一个自己的内部中控机，那么我们是必须要处理 IP 地址变化的这个问题的。我们的解决方案有如下两个步骤：

  1. 在路由器中根据 Mac 地址，为门店内的中控设备设置固定的 IP 地址
  2. 为每个娃娃机和口红挑战设备提供一个 IP 地址的配置文件，这个文件里面有门店中控的 IP 地址信息，放在 U 盘的指定目录下，但插入设备的时候，由 Rocket 程序将文件从 U 盘中将配置文件 copy 到设备的制定目录下，设备每次启动的时候都需要先读取配置文件，再连接本地的服务器。

资源什么时候更新

关于资源更新的，我们首先需要明确我们需要更新的资源有哪些以及我们需要更新的方式。

更新的资源

  • Resource.json
  • apk 包
  • 娃娃机中的显示器轮播图
  • 娃娃机中显示 banner 的 h5 资源

更新的配置文件

  • 关于我们资源跟新的所有数据都是保存在 Resource.json 这个文件夹里面的，那么我们每隔 5min 就从中控服务端（局域网内）获取 Resource.json，然后每个类型的资源就根据写在 Resource.json 中的数据进行判断。那么写入 Resource.json 文件中的实现及具体内容如下：
    1. 资源的 ResList model
    public class ResListModel {
    // 娃娃机 banner 的 h5 资源（index.html等文件）
    public HashMap bannerFiles = new HashMap();
    // 门店中所有娃娃机都会显示的轮播图
    // key 为 图片的 hash 值
    // value 为图片的在服务器中的相对路径
    public HashMap PublicFiles = new HashMap();
    // 门店中特定娃娃机的私有显示轮播图
    // key 为设备的 id
    // value 为图片图片的 hash 及路径信息（对应 PublicFiles）
    public HashMap> PrivateFiles = new HashMap();
    // 更新的 apk 路径
    public String UpdateApk;
    // 更新的 apk 包名
    public String UpdateApkPackageName;
    // 更新的 apk 版本名
    public String UpdateApkVersion;
    // 更新的 apk 版本号
    public int UpdateApkVersionCode;
}
    1. 写入到 Resourse.json 文件
        ResListModel res = new ResListModel();
    // 略过添加数据的过程
    ...;
    File resourceFile = new File(baseDir, "Resource.json");
    RandomAccessFile out = new RandomAccessFile(resourceFile, "rw");
    byte[] json = JsonStream.serialize(res).getBytes("utf-8");
    out.setLength(json.length);
    out.write(json);
    out.close();
    1. Resourse.json 的内容
    {
    "PrivateFiles":{},
    "PublicFiles":
        {
            "1A7D3394A6F10D3668FB29D8CCA1CA8B":"Public/timg.jpg"
        },
    "UpdateApk":null,
    "UpdateApkPackageName":null,
    "UpdateApkVersion":null,
    "UpdateApkVersionCode":0,
    "bannerFiles":
        {
            "C609D70832710E3DCF0FB88918113B18":"banner/Resource.json",
            "FC1CF2C83E898357E1AD60CEF87BE6EB":"banner/app.8113390c.js",
            "27FBF214DF1E66D0307B7F78FEB8266F":"banner/manifest.json",
            "A192A95BFF57FF326185543A27058DE5":"banner/index.html",
            "61469B10DBD17FDEEB14C35C730E03C7":"banner/app.8113390c.css"
            
        }
}

资源图片和 banner 的资源文件的更新

  • 关于图片和 banner 的资源文件的更新方式是类似的，只是存放的路径不在同一个目录下而已。那么对这类资源的更新，我们是通过技术资源的 hash 值和文件名来进行判断的。娃娃机或者口红挑战设备会每隔 5min 从中控中获取 Resourse.json 文件，然后取出 ResListModel，ResListModel 在之前介绍过了，是保存资源更新的配置文件；之后我们从中取出相对于的配置，首先根据文件名判断该文件是否已经存在本地了，如果不存在，则直接添加到资源更新的列表中，如果存在则再判断 hash 值是否相同，相同就不更新，不相同先将本地的文件删除，然后再将其就添加到更新资源的列表中。
  • 图片和 banner 资源更新流程图：
资源更新流程图.png
  • 中控中计算资源你的 hash 值
    try {
        // banner 资源文件
        String fileName = fileFilter.getAbsolutePath().substring(baseDirLength);
        RandomAccessFile randomAccessFile = new RandomAccessFile(fileFilter,"r");
        byte[] buf = new byte[(int) randomAccessFile.length()];
        randomAccessFile.read(buf);
        randomAccessFile.close();
        MessageDigest md5 = MessageDigest.getInstance("md5");
        byte[] hash = md5.digest(buf);
        String hashStr = ByteToHex(hash,0,hash.length);
        res.bannerFiles.put(hashStr,fileName);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

    // 字节转换为 16 进制
    public static String ByteToHex(byte[] bt, int offset, int len) {
        StringBuffer sb = new StringBuffer();
        for (int i = offset; i < offset + len; i++) {
            int tmp = bt[i] & 0xff;
            String tmpStr = Integer.toHexString(tmp);
            if (tmpStr.length() < 2)
                sb.append("0");
            sb.append(tmpStr);
        }
        return sb.toString().toUpperCase();
    }
  • 娃娃机设备检查更新（例如：banner 资源文件）
    public static Observable updateBannerRes(ResListBean resListBean) throws IOException, NoSuchAlgorithmException {
        // 获取远程 banner 的文件
        HashMap remoteFiles = new HashMap();
        for (HashMap.Entry entry : resListBean.bannerFiles.entrySet()) {
            remoteFiles.put(new File(entry.getValue()), entry.getKey());
        }

        FileUtils.GetFilesInDir(bannerDir,localBannerList,null);
        int baseDirLength = resDir.getAbsolutePath().length()+1;
        // step1：删除本地文件（远程 banner 中没有的文件）
        for (File localFile : localBannerList) {
            File chileFile = new File(localFile.getAbsolutePath().substring(baseDirLength));
            if (!remoteFiles.containsKey(chileFile)) {
                MainActivity.appendAndScrollLog(String.format("删除 banner 资源文件 %s\n", localFile.getAbsolutePath()));
                localFile.delete();
            }
        }

        // 下载本地没有的文件
        ArrayList> taskList = new ArrayList();
        for (Map.Entry fileEntry : remoteFiles.entrySet()) {
            File file = new File(resDir,fileEntry.getKey().getAbsolutePath());

            // step2：本地中存在和远程相同的文件名
            if (localBannerList.contains(file)) {
                // step3：根据 hash 值判断是否为同一文件
                String hashStr = FileUtils.getFileHashStr(file);
                if (TextUtils.equals(hashStr,fileEntry.getValue())){
                    MainActivity.appendAndScrollLog(String.format("保留 banner 文件 %s\n", file.getAbsolutePath()));
                    taskList.add(Observable.just(file));
                    continue;
                }
            }

            // step4：下载本地没有的文件
            String url = new URL("http", Config.instance.centralServerAddress,
                    Config.instance.httpPort,
                    new File(BuildConfig.APPLICATION_ID, fileEntry.getKey().getAbsolutePath()).getAbsolutePath()).toString();
            // step5：加入文件下载列表
            taskList.add(DownLoadUtils.getDownLoadFile(url,file));
        }

        return Observable.concat(taskList)
                .toFlowable(BackpressureStrategy.MISSING)
                .parallel()
                .runOn(Schedulers.io())
                .sequential()
                .toList()
                .observeOn(Schedulers.computation())
                .map(new Function, ArrayList>() {
                    @Override
                    public ArrayList apply(List files) throws Exception {
                        ArrayList list = new ArrayList();
                        for (File file : files) {
                            if (!file.getAbsolutePath().isEmpty()) {
                                list.add(file);
                            }
                        }
                        if (list.size() > 0) {
                            if (!Utils.EqualCollection(list, localBannerList)) {
                                Collections.sort(list);
                            } else {
                                list.clear();
                            }
                        }
                        return list;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Function, Boolean>() {
                    @Override
                    public Boolean apply(ArrayList list) throws Exception {
                        if (list.size() > 0) {
                            localBannerList = list;
                            webViewHasLoad = false;
                            loadH5();
                        }
                        return true;
                    }
                })
                .observeOn(Schedulers.io())
                .map(new Function() {
                    @Override
                    public Boolean apply(Boolean aBoolean) throws Exception {
                        FileUtils.DelEmptyDir(resDir);
                        return true;
                    }
                })
                .toObservable();
    }

程序升级的问题

关于程序的升级，相比较于图片资源的更新要简单许多。

  • 我们的实现版本更新的步骤如下：
    • step1：找出本地存在的 apk 文件（设备的中的 apk 都是制定路径和制定文件名的），将其删除。
    • step2：判断中控中的安装包的版本号是否大于本地程序的版本号，如果是则进入 step3；否则忽略，不需要程序升级
    • step3：下载最新版本的 apk 安装包
    • step4：下载成功后，发送广播（action：包名；extra：apk文件路径）给 rocket 程序
    • step5：rocket 程序接收到广播之后就升级程序
  • 程序升级流程图
版本更新流程.png
  • 具体代码实现

    public static Observable updateGame(ResListBean res) throws IOException, InterruptedException {
        ArrayList apkList = new ArrayList();
        FileUtils.GetFilesInDir(resDir, apkList, new String[]{
                ".apk",
        });
        // 删除本地存在的 apk 包
        for (File file : apkList) {
            file.delete();
        }
        do {
            if (res.UpdateApk == null || res.UpdateApkVersion == null) {
                break;
            }
            // 判断是否需要升级
            if (BuildConfig.VERSION_CODE >= res.UpdateApkVersionCode) {
                break;
            }
            
            // apk 的 URL
            final String url = new URL("http", Config.instance.centralServerAddress, Config.instance.httpPort, new File(BuildConfig.APPLICATION_ID, res.UpdateApk).getAbsolutePath()).toString();
            MainActivity.appendAndScrollLog(String.format("下载升级文件 %s\n", url));
            // 下载 apk 文件
            return DownLoadUtils.getDownLoadFile(url,resDir.getAbsolutePath(),res.UpdateApk)
                    .subscribeOn(Schedulers.io())
                    .observeOn(Schedulers.io())
                    .flatMap(new Function>() {
                        @Override
                        public ObservableSource apply(File file) throws Exception {
                            String path = file.getAbsolutePath();
                            MainActivity.appendAndScrollLog(String.format("升级文件下载完成 %s %s\n", path, url));
                            PackageManager pm = MainActivity.instance.getPackageManager();
                            PackageInfo pi = pm.getPackageArchiveInfo(path, 0);
                            if (pi == null) {
                                MainActivity.appendAndScrollLog(String.format("升级文件打开失败 %s\n", path));
                                return Observable.just("");
                            }
                            MainActivity.appendAndScrollLog(String.format("升级文件对比：Native(%s %s)/Remote(%s %s)\n", BuildConfig.APPLICATION_ID, BuildConfig.VERSION_NAME, pi.packageName, pi.versionName));
                            if (!BuildConfig.APPLICATION_ID.equals(pi.packageName)
                                    || BuildConfig.VERSION_CODE >= pi.versionCode) {
                                return Observable.just("");
                            }
                            return Observable.just(path);
                        }
                    })
                    .flatMap(new Function>() {
                        @Override
                        public Observable apply(String updateApk) throws Exception {
                            if (!updateApk.isEmpty()) {
                                Log.e(TAG, "等待游戏结束后安装升级文件...");
                                MainActivity.appendAndScrollLog("等待游戏结束后安装升级文件...\n");
                                synchronized (GamePlay.class) {//防止在游戏运行时更新版本
                                    Log.e(TAG, "发布广播");
                                    Intent intent = new Intent();
                                    intent.setAction(Config.updateBroadcast);
                                    intent.putExtra("apk", updateApk);
                                    MainActivity.instance.sendBroadcast(intent);
                                    System.exit(0);
                                }
                            }
                            return Observable.just(true);
                        }
                    });
        } while (false);
        return Observable.just(true);
    }

资源文件下载

关于资源文件的下载，我是选择 okdownload。okdownload 是一个支持多线程，多任务，断点续传，可靠，灵活，高性能以及强大的下载引擎。详情可以去看 okdownload GitHub 地址

  • 依赖方式
    implementation 'com.liulishuo.okdownload:okdownload:1.0.5'
    implementation 'com.liulishuo.okdownload:okhttp:1.0.5'
  • 简单实用示例

单文件下载

DownloadTask task = new DownloadTask.Builder(url, parentFile)
         .setFilename(filename)
         // the minimal interval millisecond for callback progress
         .setMinIntervalMillisCallbackProcess(30)
         // do re-download even if the task has already been completed in the past.
         .setPassIfAlreadyCompleted(false)
         .build();
 
 
task.enqueue(listener);
 
// cancel
task.cancel();
 
// execute task synchronized
task.execute(listener);

多文件下载

final DownloadTask[] tasks = new DownloadTask[2];
tasks[0] = new DownloadTask.Builder("url1", "path", "filename1").build();
tasks[1] = new DownloadTask.Builder("url2", "path", "filename1").build();
DownloadTask.enqueue(tasks, listener);
  • 结合 Rxjava 实现文件下载

public class DownLoadUtils {

    /**
     * 从中控下载文件到本地
     * @param url
     * @param parentPath            保存到本地文件的父文件路径
     * @param downloadFileName      保存到本地的文件名
     * @return
     */
    public static Observable getDownLoadFile(String url,String parentPath,String downloadFileName){
        // 下载本地没有的文件
        MainActivity.appendAndScrollLog(String.format("开始下载资源文件 %s\n", url));
        final DownloadTask task = new DownloadTask.Builder(url, parentPath, downloadFileName).build();
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(final ObservableEmitter emitter) throws Exception {
                task.enqueue(new DownloadListener2() {
                    @Override
                    public void taskStart(DownloadTask task) {

                    }

                    @Override
                    public void taskEnd(DownloadTask task, EndCause cause, Exception realCause) {
                        if (cause != EndCause.COMPLETED) {
                            MainActivity.appendAndScrollLog(String.format("资源文件下载失败 %s %s\n", cause.toString(), task.getUrl()));
                            emitter.onNext(new File(""));
                            emitter.onComplete();
                            return;
                        }
                        File file = task.getFile();
                        MainActivity.appendAndScrollLog(String.format("资源文件下载完成 %s\n", file.getAbsolutePath()));
                        emitter.onNext(file);
                        emitter.onComplete();
                    }
                });
            }
        }).retry();
    }

    /**
     * 从中控下载文件到本地
     * @param url
     * @param saveFile  保存到本地的文件
     * @return
     */
    public static Observable getDownLoadFile(String url, File saveFile){
        return getDownLoadFile(url,saveFile.getParentFile().getAbsolutePath(),saveFile.getName());
    }
}

屏蔽下拉菜单和底部导航栏

像娃娃机和格子机这些设备都是在线下直接面向用户的，因此我们不能将我们的 Android 设备全部都展现给我们的用户，我们需要对用户的行为做些限制，例如禁止用户通过导航栏或者下拉菜单退出当前程序，防止他们做出一些危险的操作。我的解决方案是把当前的 rocket 程序设置为默认启动和桌面应用程序，并将 Android 设备中自带的 launcher 程序 和 systemui 程序给禁用掉，那么设备一开始启动的时候就会启动我们的 rocket 应用，并成功的禁止了用户使用导航栏和下拉菜单来做非法的操作。

  • 查找 Android 设备中自带的 launcher 程序 和 systemui 程序的对应包名

    • 我们使用 adb shell pm list packages 就可以找出设备中已经安装的程序列表，主要是以包名显示的。
    • 查找 launcher 程序的包名，找出包名为：com.android.launcher3
    LW-PC0920@lw1002022 MINGW64 ~/Desktop
$ adb shell pm list packages | grep launcher
package:com.android.launcher3
    • 查找 systemui 程序的包名：找出包名为：com.android.systemui
    LW-PC0920@lw1002022 MINGW64 ~/Desktop
$ adb shell pm list packages | grep systemui
package:com.android.systemui

  • 禁止 Android 设备中自带的 launcher 程序 和 systemui 程序的使用

    • 禁止 launcher 程序的使用
    adb shell pm disable com.android.launcher3
    • 禁止 systemui 程序的使用
    adb shell pm disable com.android.systemui

  • 代码实现禁止 Android 设备中自带的 launcher 程序 和 systemui 程序的使用

    public static void enableLauncher(Boolean enabled) {
        List piList = MainActivity.instance.packageManager.getInstalledPackages(0);
        ArrayList packages = new ArrayList();
        for (PackageInfo pi : piList) {
            String name = pi.packageName;
            if (name.contains("systemui") || name.contains("launcher")) {
                packages.add(name);
            }
        }
        for (String packageName : packages) {
            su(String.format("pm %s %s\n", enabled ? "enable" : "disable", packageName));
        }
    }
    
    /**
     *  执行 adb 指令
     *
     */
    public static int su(String cmd) {
        try {
            Process p = Runtime.getRuntime().exec("su");
            DataOutputStream os = new DataOutputStream(p.getOutputStream());
            os.writeBytes(cmd);
            os.writeBytes("exit\n");
            os.flush();
            os.close();
            return p.waitFor();
        } catch (Exception ex) {
            return -1;
        }
    }

Iot 的实现

关于 IoT 的实现，我们这边使用的是阿里的《微消息队列 for IoT》服务，关于《微消息队列 for IoT》服务，阿里的解释如下：

微消息队列 for IoT 是消息队列（MQ）的子产品。针对用户在移动互联网以及物联网领域的存在的特殊消息传输需求，消息队列（MQ） 通过推出微消息队列 for IoT 开放了对 MQTT 协议的完整支持

  • MQTT 协议？
    • MQTT 的全称是：Message Queuing Telemetry Transport（ 消息队列遥测传输），是一种轻量的，基于发布订阅模型的即时通讯协议。该协议设计开放，协议简单，平台支持丰富，几乎可以把所有联网物品和外部连接起来，因此在移动互联网和物联网领域拥有众多优势。
  • MQTT 的特点
    • 使用发布/订阅（Pub/Sub）消息模式，提供一对多的消息分发，解除了应用程序之间的耦合；
    • 对负载内容屏蔽的消息传输；
    • 使用 TCP/IP 提供基础的网络连接；
    • 有三种级别的消息传递服务；
    • 小型传输，开销很小（头部长度固定为 2 字节），协议交换最小化，以降低网络流量。
  • 关键名词的解释
    名词 解释
    Parent Topic MQTT 协议基于 Pub/Sub 模型，因此任何消息都属于一个 Topic。根据 MQTT 协议，Topic 存在多级，定义第一级 Topic 为父 Topic（Parent Topic），使用 MQTT 前，该 Parent Topic 需要先在 MQ 控制台创建。
    Subtopic MQTT 的二级 Topic，甚至三级 Topic 都是父 Topic 下的子类。使用时，直接在代码里设置，无需创建。需要注意的是 MQTT 限制 Parent Topic 和 Subtopic 的总长度为64个字符，如果超出长度限制将会导致客户端异常。
    Client ID MQTT 的 Client ID 是每个客户端的唯一标识，要求全局唯一，使用相同的 Client ID 连接 MQTT 服务会被拒绝

Android 中实现 iot

关于显示 iot 连接的实现过程是这样的：首先我们将设备的三元组从管理后台中批量生成，文件名的格式为 deviceName.json(例如：00001.json)，里面是关于每个设备的三元组信息；接着我们将装有三元组文件的 U 盘插入到 Android 设备中（娃娃机或者口红挑战）；rocket 程序会自动监测到 U 盘的插入并将文件剪切到 Android 设备的制定目录下；再接着 Android 设备可以去读取指定文件中三元组信息；最后使用此三元组进行连接 mqtt。

  • 添加依赖
    implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.2.0'

  • 关于三元组

    • 在 Android 设备中需要关心的三个东西，mqtt 协议中用来识别一个设备的必要三要素，如果存在相同的三元组，那么必然出错，导致mqtt 频繁断开重连。三元组这个主要是在阿里的管理后台生成的，Android 设备这端只需要拿来用就可以了。
    属性 用处
    productKey 对应程序的 key，类似于 appid
    deviceName 对应上述的 Client ID，用来唯一识别一台 Android 设备的
    deviceSecret 使用 HmacSHA1 算法计算签名字符串，并将签名字符串设置到 Password 参数中用于鉴权

  • 关于订阅的 topic

    • 关于 topic 是在阿里云的后台管理中进行设置的，我们的收发消息都是通过这些 topic 来进行的。

  • 代码实现 iot 连接

    • 剪切三元组配置文件
    
/**
 * 剪切配置文件（三元组）
 * @param packageName
 */
public static void moveConfig(String packageName) {
    File usbConfigDir = new File(UsbStorage.usbPath, Config.wejoyConfigDirInUsb);
    File extProjectDir = new File(Environment.getExternalStorageDirectory(), Config.resourceDirName);
    File extConfigFile = new File(extProjectDir, Config.wejoyConfigFileInSdcard);
    if (!usbConfigDir.exists() || extConfigFile.exists()) {
        return;
    }
    extProjectDir.mkdirs();
    File[] configFiles = usbConfigDir.listFiles();
    if (configFiles.length > 0) {
        Arrays.sort(configFiles);
        moveFile(configFiles[0], extConfigFile);
    }
}

public static void moveFile(File src, File dst) {
    su(String.format("mv -f %s %s\n", src.getAbsolutePath(), dst.getAbsolutePath()));
}
    • 读取指定路径的配置文件信息(三元组）
    public static File configFile = new File(new File(Environment.getExternalStorageDirectory(), "WejoyRes"), "Config.json");

static void read() throws IOException {
    if (configFile.exists()) {
        RandomAccessFile in = new RandomAccessFile(configFile, "r");
        byte[] buf = new byte[(int) configFile.length()];
        in.read(buf);
        in.close();
        instance = JsonIterator.deserialize(new String(buf, "utf-8"), Config.class);
    } else {
        instance = new Config();
    }
    mqttRequestTopic = String.format("/sys/%s/%s/rrpc/request/", instance.productKey, instance.deviceName);
    mqttResponseTopic = String.format("/sys/%s/%s/rrpc/response/", instance.productKey, instance.deviceName);
    mqttPublishTopic = String.format("/%s/%s/update", instance.productKey, instance.deviceName);
}
    • 连接 mqtt
    
static void init() {
    instance = new IoT();
    DeviceInfo deviceInfo = new DeviceInfo();
    deviceInfo.productKey = Config.instance.productKey;
    deviceInfo.deviceName = Config.instance.deviceName;
    deviceInfo.deviceSecret = Config.instance.deviceSecret;
    final LinkKitInitParams params = new LinkKitInitParams();
    params.deviceInfo = deviceInfo;
    params.connectConfig = new IoTApiClientConfig();
    LinkKit.getInstance().registerOnPushListener(instance);
    initDisposable = Observable.interval(0, Config.instance.mqttConnectIntervalSeconds, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(Schedulers.io())
            .map(new Function() {
                @Override
                public Boolean apply(Long aLong) throws Exception {
                    if (!initialized) {
                        LinkKit.getInstance().init(MainActivity.instance, params, instance);
                    }
                    return initialized;
                }
            })
            .subscribe(new Consumer() {
                @Override
                public void accept(Boolean aBoolean) throws Exception {
                    if (aBoolean) {
                        initDisposable.dispose();
                    }
                }
            });
}
    • 发送消息：
      发送消息的时候，我们需要指定 topic，否则服务器无法接收到我们的消息。
        static void publish(String json) {
    Log.e(TAG, "publish: "+json );
    MqttPublishRequest res = new MqttPublishRequest();
    res.isRPC = false;
    res.topic = Config.mqttPublishTopic;
    res.payloadObj = json;
    LinkKit.getInstance().publish(res, new IConnectSendListener() {
        @Override
        public void onResponse(ARequest aRequest, AResponse aResponse) {
        }

        @Override
        public void onFailure(ARequest aRequest, AError aError) {
        }
    });
}
    • 接收消息： 接收消息的时候，我们也需要判断是来自哪个 topic 中的，除了我们指定的 topic，其他的 topic 我们都不做处理；当我们接收到服务器中发送来的消息的时候，我们是先判断消息的类型，然后根据相对应的类型做出不同的反应。例如我们收到后台请求给娃娃机的上分的指令，那么我们就向设备中的硬件模块发送上分的指令，并等待设备反应并给后台发送一条响应信息。这条响应的消息是需要在指定的时间内完成，否则认为超时。
    
@Override
public void onNotify(String s, final String topic, final AMessage aMessage) {
    if (!topic.startsWith(Config.mqttRequestTopic)) {
        return;
    }
    Observable.create(new ObservableOnSubscribe() {
        @Override
        public void subscribe(ObservableEmitter emitter) throws Exception {
            MqttMessage msg = JsonIterator.deserialize(new String((byte[]) aMessage.data, "utf-8"), MqttMessage.class);
            if (msg == null) {
                return;
            }
            emitter.onNext(msg);
            emitter.onComplete();
        }
    })
            .subscribeOn(Schedulers.io())
            .observeOn(Schedulers.io())
            .flatMap(new Function>() {
                @Override
                public ObservableSource apply(MqttMessage msg) throws Exception {
                    Log.e(TAG, "收到消息  key:"+msg.key+" msg:"+msg.body.m);
                    switch (msg.key) {
                        case "h": {//
                            SetHeartBeatDownstream setHeartBeatDownstream = msg.body.m.as(SetHeartBeatDownstream.class);
                            // 和设备进行通信，并等待设备的响应
                            return Device.setHeartBeat(setHeartBeatDownstream);
                        }
                        case "b": {//
                            AddCoinsDownstream addCoinsDownstream = msg.body.m.as(AddCoinsDownstream.class);
                            // 和设备进行通信，并等待设备的响应
                            return Device.addCoins(addCoinsDownstream);
                        }
                        case "g": {//
                            // 和设备进行通信，并等待设备的响应
                            return Device.getParam();
                        }
                        case "s": {//
                            SetParamDownstream setParamDownstream = msg.body.m.as(SetParamDownstream.class);
                            // 和设备进行通信，并等待设备的响应
                            return Device.setParam(setParamDownstream);
                        }
                    }
                    return Observable.never();
                }
            })
            .observeOn(Schedulers.io())
            .map(new Function() {
                @Override
                public Boolean apply(MqttMessage msg) throws Exception {
                    MqttPublishRequest res = new MqttPublishRequest();
                    res.isRPC = false;
                    res.topic = topic.replace("request", "response");
                    //res.msgId = topic.split("/")[6];
                    res.payloadObj = JsonStream.serialize(msg);
                    LinkKit.getInstance().publish(res, new IConnectSendListener() {
                        @Override
                        public void onResponse(ARequest aRequest, AResponse aResponse) {
                        }

                        @Override
                        public void onFailure(ARequest aRequest, AError aError) {
                        }
                    });
                    return true;
                }
            })
            .subscribe();
}

Android 和硬件通信

在娃娃机和口红挑战的这两个设备中，我们都需要和设备进行通信，例如：娃娃机投币、娃娃机出礼反馈、按下选中口红的格子等等这些都是需要和硬件模块进行通信的。在关于串口通信的框架选择方面，我们主要是选择 Google 的 android-serialport-api 来实现。项目原地址

  • 依赖方式

    1. 在根build.gradle中添加
    allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}
    1. 子module添加依赖
    dependencies {
    implementation 'com.github.licheedev.Android-SerialPort-API:serialport:1.0.1'
}

  • 修改su路径

// su默认路径为 "/system/bin/su"
// 可通过此方法修改
SerialPort.setSuPath("/system/xbin/su");
  • 连接方式

连接串口的时候需要指定串口号以及波特率，之后定时处理机器发送的指令。

    static void init() throws IOException {
        SerialPort.setSuPath("/system/xbin/su");
        // 设置串口号及波特率
        serialPort = new SerialPort(Config.serialPort, Config.baudrate);
        // 接收指令流
        inputStream = serialPort.getInputStream();
        // 发送指令流
        outputStream = serialPort.getOutputStream();
        // 每隔 100ms 处理机器信息
        Observable.interval(100, TimeUnit.MILLISECONDS)
                .observeOn(serialScheduler)
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        // 处理机器发送的指令
                        handleRecv();
                    }
                });
    }
  • 向机器发送指令

向机器发送指令的时候是结合 Rxjava 来实现的。除此之外，向机器发送指令是需要有规定格式的（内部制定的通信协议），我们发送及接收数据都是一个字节数组，因此我们格式是需要严格按照我们制定的协议进行的，如下是娃娃机投币的简单示例：

    static ObservableSource addCoins(final AddCoinsDownstream msg) {
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                currentUser = msg.u;
                currentHeadUrl = msg.h;
                currentNickname = msg.nk;
                byte[] buf = new byte[]{0x11, addCoinsCmd, msg.num, msg.c, 0, 0x00, 0x00};
                byte[] ret = sign(buf);
                try {
                    outputStream.write(ret);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                penddingCmd = addCoinsCmd;
                penddingEmitter = emitter;
            }
        })
                .subscribeOn(serialScheduler);
    }
  • 接收机器指令

关于接受机器消息这一块是每隔 100ms 进行的，在处理机器指令的时候，首先需要过滤到无效的字节，之后再按照我们制定的协议来处理消息，判断是娃娃机上分，还是游戏结果等信息，最后并对机器的数据返回进行 CRC16 校验。


    static void handleRecv() {
        try {
            for (; ; ) {
                int len = inputStream.available();
                if (len <= 0) {
                    break;
                }
                len = inputStream.read(buf, bufReadOffset, buf.length - bufReadOffset);
                //Log.d("serialPort", String.format("read: %s", byteToHex(buf, bufReadOffset, len)));
                bufReadOffset += len;
                for (; ; ) {
                    if (bufParseEnd == -1) {
                        for (; bufParseStart < bufReadOffset; bufParseStart++) {
                            if (buf[bufParseStart] == (byte) 0xAA) {
                                bufParseEnd = bufParseStart + 1;
                                break;
                            }
                        }
                    }
                    if (bufParseEnd != -1) {
                        for (; bufParseEnd < bufReadOffset; bufParseEnd++) {
                            if (buf[bufParseEnd] == (byte) 0xAA) {
                                bufParseStart = bufParseEnd;
                                bufParseEnd += 1;
                                continue;
                            }
                            if (buf[bufParseEnd] == (byte) 0xDD) {
                                if (bufParseEnd - bufParseStart >= 5) {
                                    bufParseEnd += 1;
                                    byte size = buf[bufParseStart + 1];
                                    byte index = buf[bufParseStart + 2];
                                    byte cmd = buf[bufParseStart + 3];
                                    byte check = (byte) (size ^ index ^ cmd);
                                    for (int i = bufParseStart + 4; i < bufParseEnd - 2; i++) {
                                        check ^= buf[i];
                                    }
                                    if (check == buf[bufParseEnd - 2]) {
                                        //Log.d("serialPort", String.format("protocol: %s, size: %d, index: %d, cmd: %d, check: %d, data: %s", byteToHex(buf, bufParseStart, bufParseEnd - bufParseStart), size, index, cmd, check, byteToHex(buf, bufParseStart + 4, size - 3)));
                                        switch (cmd) {
                                            // 心跳
                                            case heartBeatCmd: {
                                            }
                                            break;
                                            
                                            // 上分
                                            case addCoinsCmd: {
                                                
                                            }
                                            break;
                                            
                                            // 游戏结果
                                            case gameResultCmd: {
                                                boolean gift = buf[bufParseStart + 7] != 0;
                                                IoT.sendGameResult(gift);
                                                if (gift) {
                                                    // 发送用户信息到中控，进行排行榜显示
                                                    WSSender.getInstance().sendUserInfo(currentUser, currentHeadUrl, currentNickname);
                                                }
                                            }
                                            break;
                                            default:
                                                break;
                                        }
                                    }
                                }
                                bufParseStart = bufParseEnd;
                                bufParseEnd = -1;
                                break;
                            }
                        }
                    }
                    if (bufParseStart >= bufReadOffset || bufParseEnd >= bufReadOffset) {
                        break;
                    }
                }
                if (bufReadOffset == buf.length) {
                    System.arraycopy(buf, bufParseStart, buf, 0, bufReadOffset - bufParseStart);
                    if (bufParseEnd != -1) {
                        bufParseEnd -= bufParseStart;
                        bufReadOffset = bufParseEnd;
                    } else {
                        bufReadOffset = 0;
                    }
                    bufParseStart = 0;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

websocket 通信

在中控和娃娃机进行通信的方式我们是选择 websocket 进行的。中控端是 server，然后娃娃机是 client。

server

  • Server 的实现：目前 server 的实现只是为了接收娃娃机的数据反馈，所以并没有什么复杂的操作。

class WSServer extends WebSocketServer {
    private MainActivity mainActivity;

    public void setMainActivity(MainActivity mainActivity) {
        this.mainActivity = mainActivity;
    }

    WSServer(InetSocketAddress address) {
        super(address);
    }

    @Override
    public void onOpen(WebSocket conn, ClientHandshake handshake) {
        mainActivity.appendAndScrollLog("客户端：" + conn.getRemoteSocketAddress() + " 已连接\n");
    }

    @Override
    public void onClose(WebSocket conn, int code, String reason, boolean remote) {
        mainActivity.appendAndScrollLog("客户端：" + conn.getRemoteSocketAddress() + " 已断开\n");
    }

    @Override
    public void onMessage(WebSocket conn, final String message) {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                final SocketMessage socketMessage = JsonIterator.deserialize(message, SocketMessage.class);
                emitter.onNext(socketMessage);
                emitter.onComplete();
            }
        })
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(SocketMessage socketMessage) throws Exception {
                        if (socketMessage.getCode() == SocketMessage.TYPE_USER) {
                            // 夹到娃娃
                            
                        } else if (socketMessage.getCode() == SocketMessage.TYPE_SAY_HELLO) {
                            // 连接招呼语
                        }
                    }
                });


    }

    @Override
    public void onError(WebSocket conn, Exception ex) {
    }

    @Override
    public void onStart() {

    }
}
  • 简单使用方式
    appendAndScrollLog("初始化WebSocket服务...\n");
    WSServer wsServer = new WSServer(18104);
    wsServer.setMainActivity(MainActivity.this);
    wsServer.setConnectionLostTimeout(5);
    wsServer.setReuseAddr(true);
    wsServer.start();
    appendAndScrollLog("初始化WebSocket服务完成\n");

client

在 client 端，目前需要做的人物有断开重连以及数据发送的操作。断开重连的时候需要在新的子线程中进行，否则会报如下错误：

You cannot initialize a reconnect out of the websocket thread. Use reconnect in another thread to insure a successful cleanup

因此，我们每次断开重新的时候是需要在新的子线程中进行的。除此之外，在发送数据的时候，如果刚好 socket 没有连接上，那么发送数据是会报异常的，因此我们有数据要发送的时候如果 socket 没有连接，那么就先缓存到本地，等到 socket 连接上之后再把滞留的数据一次性发送出去。

  • 依赖配置
    implementation 'org.java-websocket:Java-WebSocket:1.3.9'
  • WSClient.java

class WSClient extends WebSocketClient {

    private static final String TAG = "WSClient";
    private static WSClient instance;
    private static URI sUri;
    private WSReceiver mWSReceiver;
    private Disposable mReconnectDisposable;
    private ConnectCallback mConnectCallback;

    /**
     * step 1:需要先调用，设置 url
     * @param uri
     */
    public static void setUri(URI uri){
        sUri = uri;
    }

    /**
     * step 1:
     * 需要先调用，设置服务端的 url
     * @param ipAddress
     * @param port
     */
    public static void setUri(String ipAddress,int port){
        try {
            sUri = new URI(String.format("ws://%s:%d", ipAddress, port));
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }


    public static WSClient getInstance(){
        if (instance == null) {
            synchronized (WSClient.class){
                if (instance == null) {
                    instance = new WSClient(sUri);
                }
            }
        }
        return instance;
    }

    /**
     * step 2：连接 websocket
     */
    public void onConnect(){
        setConnectionLostTimeout(Config.instance.webSocketTimeoutSeconds);
        setReuseAddr(true);
        connect();
    }

    private WSClient(URI server) {
        super(server);
        // 初始化消息发送者
        WSSender.getInstance().setWSClient(this);
        // 初始化消息接收者
        mWSReceiver = new WSReceiver();
        mWSReceiver.setWSClient(this);
        mWSReceiver.setWSSender(WSSender.getInstance());

    }


    @Override
    public void onOpen(ServerHandshake handshakedata) {
        Log.d(TAG, "onOpen: ");
        MainActivity.appendAndScrollLog("websocket 已连接\n");
        Observable.just("")
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        if (mConnectCallback != null) {
                            mConnectCallback.onWebsocketConnected();
                        }
                    }
                });

        // 清除滞留的所有消息
        WSSender.getInstance().clearAllMessage();
        
    }

    @Override
    public void onMessage(String message) {
        Log.d(TAG, "onMessage: ");
        mWSReceiver.handlerMessage(message);
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        Log.d(TAG, "onClose: ");
        MainActivity.appendAndScrollLog(String.format("websocket 已断开,断开原因：%s\n",reason));
        Observable.just("")
                .subscribeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Object o) throws Exception {
                        if (mConnectCallback != null) {
                            mConnectCallback.onWebsocketClosed();
                        }
                    }
                });
        onReconnect();
    }

    @Override
    public void onError(Exception ex) {
        if (ex != null) {
            Log.d(TAG, "onError: "+ex.getMessage());
            MainActivity.appendAndScrollLog(String.format("websocket 出现错误,错误原因：%s\n",ex.getMessage()));
        }
        onReconnect();
    }


    public void onReconnect() {
        if (mReconnectDisposable != null
                && !mReconnectDisposable.isDisposed()){
            return;
        }
        mReconnectDisposable = Observable.timer(1, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG, "websocket reconnect");
                        WSClient.this.reconnect();
                        mReconnectDisposable.dispose();
                    }
                });

    }

    public void setConnectCallback(ConnectCallback mConnectCallback) {
        this.mConnectCallback = mConnectCallback;
    }

    public interface ConnectCallback{
        void onWebsocketConnected();
        void onWebsocketClosed();
    }
}

 
 
     
  
  • WSSender.java
    •  
 
 
 

/**
 * Created by runla on 2018/10/26.
 * 文件描述：Websocket 的消息发送者
 */

public class WSSender {
    private static final String TAG = "WSSender";
    public static final int MAX_MESSAGE_COUNT = 128;
    private static WSSender instance;
    private WSClient mWSClientManager;
    // 消息队列
    private LinkedList mMessageList = new LinkedList<>();

    private WSSender() {
    }

    public static WSSender getInstance() {
        if (instance == null) {
            synchronized (WSSender.class) {
                if (instance == null) {
                    instance = new WSSender();
                }
            }
        }
        return instance;
    }

    public void setWSClient(WSClient wsClientManager) {
        this.mWSClientManager = wsClientManager;
    }

    /**
     * 发送所有滞留的消息
     */
    public void clearAllMessage() {
        if (mWSClientManager == null) {
            return;
        }

        while (mMessageList.size() > 0
                && mMessageList.getFirst() != null) {
            Log.d(TAG, "sendMessage: " + mMessageList.size());
            mWSClientManager.send(mMessageList.getFirst());
            mMessageList.removeFirst();
        }
    }

    /**
     * 发送消息，如果消息发送不出去，那么就等到连接成功后再次尝试发送
     *
     * @param msg
     * @return
     */
    public boolean sendMessage(String msg) {
        if (mWSClientManager == null) {
            throw new NullPointerException("websocket client is null");
        }
        if (TextUtils.isEmpty(msg)) {
            return false;
        }
        // 将需要发送的数据添加到队列的尾部
        mMessageList.addLast(msg);

        while (mMessageList.size() > 0
                && mMessageList.getFirst() != null) {
            Log.d(TAG, "sendMessage: " + mMessageList.size());
            if (!mWSClientManager.isOpen()) {
                // 尝试重连
                mWSClientManager.onReconnect();
                break;
            } else {
                mWSClientManager.send(mMessageList.getFirst());
                mMessageList.removeFirst();
            }
        }

        // 如果消息队列中超过我们设置的最大容量，那么移除最先添加进去的消息
        if (mMessageList.size() >= MAX_MESSAGE_COUNT) {
            mMessageList.removeFirst();
        }
        return false;
    }
}


 
 
     
  
  • WSReceiver.java
    •  
 
 
 

/**
 * Created by runla on 2018/10/26.
 * 文件描述：Websocket 的消息接收者
 */

public class WSReceiver {
    private WSClient mWSClientManager;
    private WSSender mWSSender;
    private OnMessageCallback onMessageCallback;
    public WSReceiver() {
    }


    public void setWSClient(WSClient mWSClientManager) {
        this.mWSClientManager = mWSClientManager;
    }

    public void setWSSender(WSSender mWSSender) {
        this.mWSSender = mWSSender;
    }

    /**
     * 处理接收消息
     * @param message
     */
    public void handlerMessage(String message){

        if (onMessageCallback != null){
            onMessageCallback.onHandlerMessage(message);
        }
    }

    public void setOnMessageCallback(OnMessageCallback onMessageCallback) {
        this.onMessageCallback = onMessageCallback;
    }

    public interface OnMessageCallback{
        void onHandlerMessage(String message);
    }
}


 
 
     
  
  • 连接调用
    •  
 
 
 
    appendAndScrollLog("初始化WebSocket客户端...\n");
    WSClient.setUri( Config.instance.centralServerAddress, Config.instance.webSocketPort);
    WSClient.getInstance().onConnect();
    WSClient.getInstance().setConnectCallback(MainActivity.this);
    appendAndScrollLog("初始化WebSocket客户端完成\n");


 
 
     
  
  • 数据发送
    •  
 
 
 
// 清除滞留的所有消息
WSSender.getInstance().clearAllMessage();

// 发送消息
WSSender.getInstance().sendMessage(msg);


 
 
数据库存储
 
 
在中控端，我们需要显示排行版，用来显示夹中娃娃机的用户在本月及本周夹中娃娃的排行，因此我们需要再中控端保存用户的夹中娃娃数量以及个人的其他信息，GreenDAO 是一款开源的面向 Android 的轻便、快捷的 ORM 框架，将 Java 对象映射到 SQLite 数据库中，我们操作数据库的时候，不在需要编写复杂的 SQL语句， 在性能方面，GreenDAO 针对 Android 进行了高度优化， 最小的内存开销 、依赖体积小，同时还是支持数据库加密。关于 GreenDAO 的用法我就不在这里做，具体的用法可以参考官网 GreenDAO。
 
 
 
 
写在最后
 
 
关于整个系统的架构搭建过程中遇到了好多坑，以上是我为这个项目提供的部分解决方案，当前全部的是不可能都放写出来的，此项目目前已经在西安和成都等地都有门店点了，据反馈，利润极大，不过这种类型的项目红利期不会太长，估计也是 2~3 年左右吧。如果有需要我们为 口红机开发 或者是 娃娃机开发 提供解决方案的，可以联系我们，目前我们在这个方面已经有相对较为成熟的解决方案了。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android 抖音爆红的口红挑战爬坑总结)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

                        
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    
                    
    • 
                                
  • web报表工具FineReport常见的数据集报错错误代码和解释
                                    老A不折腾
web报表finereport代码可视化工具
                                    
    在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 
  
NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 
NS_LayerReport_MultiDs=错误代码
    
                                
    • 
                                
  • Java的WeakReference与WeakHashMap
                                    bylijinnan
java弱引用
                                    
    首先看看 WeakReference 
 
wiki 上 Weak reference 的一个例子： 
 
 

	public class ReferenceTest {
	public static void main(String[] args) throws InterruptedException {
 
            WeakReference r = new Wea
    
                                
    • 
                                
  • Linux——（hostname）主机名与ip的映射
                                    eksliang
linuxhostname
                                    
    一、 什么是主机名 
无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的； 
主机名是用于什么的呢？ 
答：在一个局域网中，每台机器都有一个主
    
                                
    • 
                                
  • oracle 常用技巧
                                    18289753290

                                    
    oracle常用技巧   ①复制表结构和数据     create table  temp_clientloginUser   as     select distinct userid from tbusrtloginlog   ②仅复制数据   如果表结构一样   insert into  mytable  select  * &nb
    
                                
    • 
                                
  • 使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException
                                    酷的飞上天空
exception
                                    
    有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
    
                                
    • 
                                
  • IT系统分析师如何学习大数据
                                    蓝儿唯美
大数据
                                    
    我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系 统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
    
                                
    • 
                                
  • spring学习——简介
                                    a-john
spring
                                    
    Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 
 
为了降低Java开发的复杂性，
    
                                
    • 
                                
  • 自定义颜色的xml文件
                                    aijuans
xml
                                    
    <?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
    
                                
    • 
                                
  • 运营到底是做什么的？
                                    aoyouzi
运营到底是做什么的？
                                    
    文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
    
                                
    • 
                                
  • js面向对象类和对象
                                    百合不是茶
js面向对象函数创建类和对象
                                    
    接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言 但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下  ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似 
  
下面介绍一些js的类和对象的创建的技术 
  
一:类和对
    
                                
    • 
                                
  • web.xml之资源管理对象配置 resource-env-ref
                                    bijian1013
javaweb.xmlservlet
                                    
    resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 
<resource-env-ref>
    <resource-env-ref-name>资源名</resource-env-ref-name>
    <resource-env-ref-type>查找资源时返回的资源类
    
                                
    • 
                                
  • Create a composite component with a custom namespace
                                    sunjing

                                    
    https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace 
  
When you developed a composite component the namespace you would be seeing would 
    
                                
    • 
                                
  • 【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter
                                    bit1129
mongodb
                                    
     一、复本集为什么要加入Arbiter这个角色   回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。   什么是Artiber？   An arbiter does 
not have a copy of data set and 
cannot become a primary. Replica sets may have arbiters to add a 
    
                                
    • 
                                
  • Javascript开发笔记
                                    白糖_
JavaScript
                                    
     
 获取iframe内的元素 
 
通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
    
                                
    • 
                                
  • Web浏览器Chrome打开一段时间后，运行alert无效
                                    bozch
Webchormealert无效
                                    
    今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。 
试了试其他浏览器，发现都是没有问题的。 
开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。 
这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了 就关闭浏览器重启。 
  
结果就好了，这也太怪异了。难道是cho
    
                                
    • 
                                
  • 编程之美-高效地安排会议 图着色问题 贪心算法
                                    bylijinnan
编程之美
                                    
    

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class GraphColoringProblem {

	/**编程之美 高效地安排会议 图着色问题 贪心算法
	 * 假设要用很多个教室对一组
    
                                
    • 
                                
  • 机器学习相关概念和开发工具
                                    chenbowen00
算法matlab机器学习
                                    
    基本概念： 
机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。 
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。 
 
开发工具 
M
    
                                
    • 
                                
  • [宇宙经济学]关于在太空建立永久定居点的可能性
                                    comsci
经济
                                    
     
       大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 
 
       所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
    
                                
    • 
                                
  • oracle 11g database control 证书错误
                                    daizj
oracle证书错误oracle 11G 安装
                                    
    oracle 11g database control 证书错误  
 
win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面 
 
解决办法： 
 
是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
    
                                
    • 
                                
  • Java I/O之用FilenameFilter实现根据文件扩展名删除文件
                                    游其是你
FilenameFilter
                                    
    在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。 
在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16 
    
                                
    • 
                                
  • C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例
                                    dcj3sjt126com
carray
                                    
    # include <stdio.h>

int main(void)
{
	
	int a[5] = {1, 2, 3, 4, 5};
		//a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4]
	
	int i;

	for (i=0; i<5; ++i)
		printf("%d\n",
    
                                
    • 
                                
  • PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。 就是 唯一 且 不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引
                                    dcj3sjt126com
primary
                                    
    PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。 就是 唯一 且 不能为空。INDEX 索引，普通的UNIQUE 唯一索引。 不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号   INT会员姓名  
    
                                
    • 
                                
  • java集合辅助类 Collections、Arrays
                                    shuizhaosi888
CollectionsArraysHashCode
                                    
      
Arrays、Collections 
  
1 ）数组集合之间转换 
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    } 
     a）Arrays.asL
    
                                
    • 
                                
  • Spring Security（10）——退出登录logout
                                    234390216
logoutSpring Security退出登录logout-urlLogoutFilter
                                    
           要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
    
                                
    • 
                                
  • 透过源码学前端 之 Backbone 三 Model
                                    逐行分析JS源代码
backbone源码分析js学习
                                    
    Backbone 分析第三部分  Model 
概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里， 
但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件， 
如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。 
    
                                
    • 
                                
  • SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter
                                    乒乓狂魔
springMVC
                                    
    这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 
 
HttpMessageConverter接口介绍： 
 

public interface HttpMessageConverter<T> {

	/**
	 * Indicate
    
                                
    • 
                                
  • 分布式基础知识和算法理论
                                    bluky999
算法zookeeper分布式一致性哈希paxos
                                    
       
分布式基础知识和算法理论 
BY [email protected] 
本文永久链接：http://nodex.iteye.com/blog/2103218 
  
在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
    
                                
    • 
                                
  • Android Studio的.gitignore以及gitignore无效的解决
                                    bell0901
androidgitignore
                                    
    　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 
　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了 
　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store 
    
                                
    • 
                                
  • 成为高级程序员的10个步骤
                                    tomcat_oracle
编程
                                    
    What 
软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 
  
Why 
 
  得到更多的报酬！因为你的薪水会随着你水平的提高而增加  
  提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进  
  历经更大的挑战。随着你的成长，各种影响力也会提高。  
    
                                
    • 
                                
  • mongdb在linux下的安装
                                    xtuhcy
mongodblinux
                                    
    一、查询linux版本号： 
lsb_release -a  
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa
    
                                
    •