Rx学习笔记和总结

最新推荐文章于 2022-05-16 17:07:19 发布
最新推荐文章于 2022-05-16 17:07:19 发布
阅读量768 收藏 1
点赞数
分类专栏： RxJava RxAndroid 文章标签： 设计模式 响应式 RxJava Observer RxAndroid

转载来源http://blog.csdn.net/wuyinlei/article/details/52004099

RxAndroid学习笔记和总结

前言

rx系列貌似在前一阶段火起来的，也是自己接触的少，一直没有去学习，今天就趁着周六，脑补一下。

什么是Rx

  • Rx是响应式编程的意思，本质上就是观察者设计模式，是以观察者（Observer）和订阅者（Subscriber）为基础的异步响应方式
  • 在Android编程的时候，经常使用后台线程，那么就可以使用这种方式，能够使得逻辑比较清晰明了(有的人说会增加好多的代码，但是我觉得代码的链式结构让代码看起来更加简洁明了)

Rx模式以及有点

优势一
  • 创建：Rx可以方便的创建事件流和数据流
  • 组合：Rx使用查询式的操作符合组合和变换数据流
  • 监听：Rx可以订阅任何可观察的数据量并执行操作
优势二(简化代码)
  • 函数式风格：对可观察数据流使用无副作用的输入流输出函数，避免了程序里面的错综复杂的状态
  • 简化代码：Rx的操作符通常可以将复杂的难题简化成很少的几行代码(配合lambda表达式还能简化)
  • 异步错误处理：Rx提供了何时的错误处理机制
  • 轻松使用并发：Rx的Observables和Schedulers让开发着可以很方便的切换UI线程和子线程，摆脱底层的线程同步和各种并发问题

响应式编程

Rx提供了一系列的操作符，你可以使用它们来过滤(filter)、选择(select)、变换(transform)、结合(combine)和组合(compose)多个Observable，这些操作符让执行和符合变得非常高效。
你可以把Observable当做Iterable的推送方式的等价物，使用Iterable，消费者从生产者那拉取数据，线程阻塞直至数据准备好，使用Observable，在数据准备好的时候，生产者将数据推送给消费者，数据可以同步或者异步的到达，方式更加灵活。

RxJava观察者模式

  • 需求：A对象(观察者)对B对象(被观察者)的某种变化高度敏感，需要在B变化的一瞬间做出反应。
  • RxJava四个基本概念
    • Observable(被观察者)
    • Observer(观察者)
    • subscribe(订阅)
    • 事件
  • Observable和Observer通过subscribe()方法实现订阅的关系，从而Observable可以在需要的时候发出事件来通知Observer。

关于理论的知识，网上的介绍的太多了，大家可以去看下，在文章的结尾，我也会附几篇好的文章。

手动实现观察者模式

首先我们需要有观察者和被观察者。
被观察者接口(里面简单的定义添加观察者，移除观察者，通知观察者三个方法)
public interface Watched {
    //添加观察者
    public void addWatcher(Watcher watcher);
    //移除观察者
    public void removeWatcher(Watcher watcher);
    //通知观察者
    public void notifyWathers(String str);
}
观察者接口(定义更新的方法)
public interface Watcher {
    //数据变化进行更新
    public void update(String str);
}
被观察者实现类

public class ConcreteWathed implements Watched {
    //观察者
    List<Watcher> mList = new ArrayList<>();

    @Override
    public void addWatcher(Watcher watcher) {
        mList.add(watcher);
    }

    @Override
    public void removeWatcher(Watcher watcher) {
        mList.remove(watcher);
    }

    @Override
    public void notifyWathers(String str) {
        for (Watcher w : mList) {
            w.update(str);
        }
    }
}
观察者实现类
public class ConcreteWather implements Watcher {
    @Override
    public void update(String str) {
        System.out.println(str);
    }
}
测试类
 public static void main(String[] args){
        Watched watched = new ConcreteWathed();
        Watcher watcher1 = new ConcreteWather();
        Watcher watcher2 = new ConcreteWather();
        Watcher watcher3 = new ConcreteWather();

        watched.addWatcher(watcher1);
        watched.addWatcher(watcher2);
        watched.addWatcher(watcher3);

        watched.notifyWathers("I go");
    }
输出结果
I go
I go
I go

当然了，这只是简单的实现，只要晓得原理就行，除了自己实现，官方也给我们提供了观察者与被观察者接口。只要我们去实现接口就可以了。

利用系统提供的类和接口实现观察者模式

被观察者
public class XTObservable extends Observable {

    private int data = 0;

    public int getData(){
        return data;
    }

    public void setData(int i){
        if (this.data != i){
            this.data = i;
            setChanged();//发生改变
            notifyObservers();//通知观察者
        }
    }
}
观察者

public class XTobserver implements Observer {

    public XTobserver(XTObservable observable) {
        observable.addObserver(this);
    }

    @Override
    public void update(Observable observable, Object o) {
        System.out.println("data is changed" + ((XTObservable) observable).getData());
    }
}
测试类
public class Test {

    public static void main(String[] args) {
        XTObservable mObservable = new XTObservable();
        XTobserver mXTobserver = new XTobserver(mObservable);
        mObservable.setData(1);
        mObservable.setData(2);
        mObservable.setData(3);
    }
}
输出结果
data is changed1
data is changed2
data is changed3

上面已经手动实现观察者模式和通过系统提供类实现，当然这都不是重点，重点是Rx响应式编程

RxAndroid使用

一：使用前配置

在项目工程的build.gradle文件添加这样的一句话(如果使用lambda)

 classpath 'me.tatarka:gradle-retrolambda:2.5.0'（这一句在gradle版本下面紧接着）

在该module工程的build.gradle文件中添加

apply plugin: 'me.tatarka.retrolambda'（使用lambda）在文件的第二行

在buildTypes节点的下(不是节点内)添加下面一句

 compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

然后在依赖中添加下面几句(没有提示一定添加的可以根据自己选择性添加)

//rx一定添加
 compile 'io.reactivex:rxjava:1.1.0'
    compile 'io.reactivex:rxandroid:1.1.0'
    compile 'com.google.code.gson:gson:2.4'
    compile 'com.jakewharton:butterknife:7.0.1'
    compile 'com.squareup.picasso:picasso:2.5.2'
    //添加
    compile 'com.squareup.okhttp3:okhttp:3.+'

至此，使用环境已经配置好了，接下来我们来简单的使用一下。

利用create创建来使用Rx
/**
     * 使用create方式
     */
    public static void createObserable() {
        //定义被观察者
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                if (!subscriber.isUnsubscribed()) { //观察者和被观察者还有订阅消息
                    subscriber.onNext("hello"); //返回的数据
                    subscriber.onNext("hi");
                    subscriber.onNext(getUserName());  //因为是传入的是字符串泛型
                    subscriber.onCompleted(); //完成
                }
            }
        });

        //定义观察者
        Subscriber showSub = new Subscriber() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");   //用于对话框消失
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.getMessage());   //错误处理
            }

            @Override
            public void onNext(Object o) {
                Log.i(TAG, o.toString());
            }
        };

        observable.subscribe(showSub); //两者产生订阅
    }

    /**
     * 可以用来写成我们的下载返回数据
     *
     * @return
     */
    public static String getUserName() {
        return "jsonName";
    }

在主activity中调用，我们来看下控制台输出的结果：

也是一个测试，打印
  /**
     * 打印的功能  链式结构，更加易于代码的可毒性
     */
    public static void createPrint() {
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (!subscriber.isUnsubscribed()) {
                    for (int i = 0; i < 10; i++) {
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.i(TAG, "result--->:" + integer);
            }
        });
    }

看下控制台结果

from函数
 /**
     * 使用在被观察者，返回的对象一般都是数据类型
     * 它接收一个集合作为输入，然后每次输出一个元素给subscriber
     */
    public static void from() {
        Integer[] items = {1, 2, 3, 4, 5, 6, 7, 8};
        Observable onservable = Observable.from(items);
        onservable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i(TAG, o.toString());
            }
        });
    }

控制台结果

interval函数
/**
     * 指定某一时刻进行数据发送
     * interval()函数的两个参数：一个指定两次发射的时间间隔，另一个是用到的时间单位
     */
    public static void interval() {
        Integer[] items = {1, 2, 3, 4};
        Observable observable = Observable.interval(1, 1, TimeUnit.SECONDS);
        observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i(TAG, o.toString());
            }
        });
    }
just函数
  /**
     * 假如我们只有3个独立的AppInfo对象并且我们想把他们转化为Observable并填充到RecyclerView的item中：
     * 这里我们有两个数组，然后通过转化为Observable组成一个item
     */
    public static void just() {
        Integer[] items1 = {1, 2, 3, 4};
        Integer[] items2 = {2, 4, 6, 8};

        Observable observable = Observable.just(items1, items2);
        observable.subscribe(new Subscriber<Integer[]>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.getMessage());
            }

            @Override
            public void onNext(Integer[] integers) {
                for (int i = 0; i < integers.length; i++) {
                    Log.i(TAG, "result--->" + i);
                }
            }
        });
    }

输出结果：

range函数
  /**
     * 指定输出数据的范围
     */
    public static void range() {
        Observable observable = Observable.range(1, 4);
        observable.subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.getMessage());
            }

            @Override
            public void onNext(Integer o) {
                Log.i(TAG, "next---->" + o);
            }
        });
    }

输出结果：

filter函数
 /**
     * 使用过滤功能  发送消息的时候，先过滤在发送
     */
    public static void filter() {
        Observable observable = Observable.just(1, 2, 3, 4, 5, 6);
        observable.filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer o) {
                return o < 5;
            }
        }).observeOn(Schedulers.io()).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, e.getMessage());
            }

            @Override
            public void onNext(Object o) {
                Log.i(TAG, o.toString());
            }
        });
    }

输出结果：

好了，几个常用到的函数已经介绍完了，接下来就用几个例子来说验证一下吧。

使用Rx+OkHttp下载图片

Rx下载的封装
 /**
     * 声明一个被观察者对象，作为结果返回
     */
    public Observable<byte[]> downLoadImage(String path) {
        return Observable.create(new Observable.OnSubscribe<byte[]>() {
            @Override
            public void call(Subscriber<? super byte[]> subscriber) {
                if (!subscriber.isUnsubscribed()) {  //存在订阅关系
                    //访问网络操作
                    //请求体
                    Request request = new Request.Builder().url(path).get().build();
                    //异步回调
                    mOkHttpClient.newCall(request).enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                            subscriber.onError(e);
                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            if (response.isSuccessful()) {
                                byte[] bytes = response.body().bytes();
                                if (bytes != null) {
                                    subscriber.onNext(bytes);  //返回结果
                                }
                            }
                            subscriber.onCompleted();  //访问完成
                        }
                    });

                }
            }
        });
    }
在使用的时候调用
   //使用HTTP协议获取数据
            mUtils.downLoadImageOne(url)
                    .subscribeOn(Schedulers.io())  //在子线程请求
                    .observeOn(AndroidSchedulers.mainThread()) //结果返回到主线程这一步很厉害啊，不用我们去用handler或者async切换线程了
                    // 主要我们去调用一下代码，就已经帮我们切换好了线程，是不是感觉有点很厉害啊
                    .subscribe(new Subscriber<byte[]>() {
                @Override
                public void onCompleted() {
                    Log.i(TAG,"onCompleted");//对话框消失
                }

                @Override
                public void onError(Throwable e) {
                    Log.i(TAG,e.getMessage());
                }

                @Override
                public void onNext(byte[] bytes) {
                    Bitmap bitmap = BitmapFactory.decodeByteArray(bytes,0,bytes.length);
                    mImageView.setImageBitmap(bitmap);
                }
            });

Rx+okhttp实现登录

  /**
     * 
     * @param url  登录地址
     * @param params  请求参数
     * @return   后台返回的数据
     */
    public Observable<String> login(String url, Map<String, String> params) {

        return Observable.create((Observable.OnSubscribe<String>) subscriber -> {
            if (!subscriber.isUnsubscribed()) {
                //创建formbody
                FormBody.Builder builder = new FormBody.Builder();
                if (params != null && !params.isEmpty()) {
                    //循环获取body中的数据
                    for (Map.Entry<String, String> entry : params.entrySet()) {
                        builder.add(entry.getKey(), entry.getValue());
                    }
                }
                //请求体
                RequestBody requestBody = builder.build();
                Request request = new Request.Builder().url(url).post(requestBody).build();
                mOkHttpClient.newCall(request).enqueue(new Callback() {
                    @Override
                    public void onFailure(Call call, IOException e) {
                        subscriber.onError(e);
                    }

                    @Override
                    public void onResponse(Call call, Response response) throws IOException {
                        if (response.isSuccessful()) {
                            //交给观察者处理数据
                            subscriber.onNext(response.body().string());
                        }
                        //完成的回调
                        subscriber.onCompleted();
                    }
                });
            }
        });
    }
登录调用
  Map<String, String> params = new HashMap<String, String>();
            params.put("username", userName.getText().toString().trim());
            params.put("password", passWord.getText().toString().trim());
            mUtils.login(url, params).subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread()).subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    Log.i(TAG, "onCompleted");
                }

                @Override
                public void onError(Throwable e) {
                    Log.i(TAG, e.getMessage());
                }

                @Override
                public void onNext(String s) {
                    if (JsonUtils.parse(s)) {
                        Intent intent = new Intent(LoginActivity.this, ContentActivity.class);
                        startActivity(intent);
                    }
                }
            });


如果有想需要代码的，可以看这里，所有代码已经传至github。https://github.com/wuyinlei/RxAndroidDemo
好了，就先介绍到这里吧，这里在给大家推荐几篇比较好的博文还有。

推荐博文

推荐git

结语

Rx使用还是挺方便的，不过需要一定的学习成本，谨慎使用(嘿嘿)

shanshan_blog
关注
专栏目录
蓝桥杯学习笔记六：usart Rx的配置和使用（uart）
qq_46931312的博客
01-24 1962
为什么是uart而不是usart？ 因为是在XCOM里直接输入完成所有的数据再发送，接着单片机再逐个接收数据直至结束符，所以是异步模式，也就是uart 为什么涉及到中断？ 因为在实际应用中肯定不知道什么时候才接收数据，所以需要中断的形式。 程序运行的过程？ 1、打开中断入口（也就是准备接收） HAL_UART_Receive_IT(&huart1, rx, 1);//huart1代表是uart1 ...
rx学习
04-13 223
我们先了解rxjs的使用原理，在了解他的实现方法。 #### 如果理解observable构造函数中的next和你执行subscrible中的next呢。你在构造函数中调用的next就是subscrible中的next。你多次的subscrible就会多次执行构造函数，多次的next方法也是不同的。 ### 如何理解rxjs的单播和多播。 只有一个observer可以播的我们...
java rx.observable_Rxjava2 Observable的条件操作符详解及实例
weixin_31967737的博客
02-26 448
简要：需求了解：在使用 Rxjava 开发中，经常有一些各种条件的操作 ，如比较两个 Observable 谁先发射了数据、跳过指定条件的 Observable 等一系列的条件操作需求，那么很幸运， Rxjava 中已经有了很多条件操作符，一起来了解一下吧。下面列出了一些Rxjava的用于条件操作符：Amb：给定两个或多个Observables，它只发射首先发射数据或通知的那个Observable...
RxJava中Observable的基本用法
tyxo的博客
09-20 9318
1.前言 随着RxJava越来越火，相信在2016年必定会大方异彩。 虽然前前后后看了不少RxJava的文章，但都没有积累下来，又没有在实际项目中使用过。 因此特意写下这篇文章记录学习过程。 1.简介RxJava 一般我们进行耗时任务，如网络、数据库查询、复杂计算等等，我们都回开启一个线程，然后通过接口回调，获取我们的结果。 但随着我们业务逻辑的越来越复杂，我们就会陷入一个回调地狱，回调里面还...
java rx.observable_Rxjava2 Observable的数据变换详解及实例（二）
weixin_30537231的博客
02-26 471
1. Window定期将来自原始Observable的数据分解为一个Observable窗口，发射这些窗口，而不是每次发射一项数据。Window 和 Buffer 类似，但不是发射来自原始Observable的数据包，它发射的是 Observables，这些Observables中的每一个都发射原始Observable数据的一个子集，最后发 射一个onCompleted通知。和 Buffer一样，...
STM32-串口实验学习笔记
08-11
总结起来，STM32串口实验中的这个学习笔记主要讲解了如何利用中断服务函数和自定义协议来管理串口数据的接收，以及如何处理不同长度的数据包。通过这个例子，我们可以深入理解STM32的串口工作模式和中断处理，为以后...
STM32 CAN通信的学习笔记总结（从小白开始）
热门推荐
不善挽留
07-30 4万+
本文记录了学习CAN的过程，作为自己以后复习的笔记参考，对于前文的理解或许有些浅显（为了易懂），所涉及到的知识点在后文都会讲到
兄弟连学习笔记
02-17
### 兄弟连学习笔记知识点总结 #### Linux基础命令学习 **知识点1：Find命令** - **find/**：从根目录开始查找。 - **find /etc -name "jiangwen"**：在/etc目录下查找名为jiangwen的文件。 - **find /etc -iname ...
java rx.observable_Rxjava2 Observable的数据变换详解及实例（一）
weixin_39678426的博客
02-26 377
简要：需求了解：对于 Observable 发射的数据有的时候可能不满足我们的要求，或者需要转化为其他类型的数据，比如：缓存，数据类型转化，数据拦截等。此时可以使用 Rx 中的一些对于数据操作的操作进行数据的变换，方便我们的开发。执行变换的操作方法：Buffer：它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个Map：对序列的每一项都应用一个函数来变换...
RxJava 3.0 中Observable 种类简介
sky丶伤心欲绝的博客
05-16 947
RxJava 3.0 Observable 种类
RxJava学习篇之一：基础Observable,Observer,Single,Subject,Scheduler
十一月Siy
09-05 4077
本文介绍Rxjava中的基础Observable，Observer，Single,Subject,Scheduler基础知识。 实例演示了每个的用法。
java rx.observable_RxJava Observable
weixin_39574720的博客
02-26 210
我正在努力研究我的第一个RxJava示例我有一个带有文本框和三个按钮的主要活动 . 第一个按钮在单独的类中初始化一个整数 . 第二个按钮订阅了一个观察整数的观察者 . 第三个按钮将整数值减一 .这是我的代码package com.someurl.www.myobservable;import android.support.v7.app.ActionBarActivity;import andro...
入门Rx-Observable的创建方式
xiaohuanqi的博客
01-24 3859
博客转移到个人站点：http://www.wangchengmeng.club/2018/02/01/%E5%85%A5%E9%97%A8Rx-Observable%E7%9A%84%E5%88%9B%E5%BB%BA%E6%96%B9%E5%BC%8F/ 欢迎来吐槽 /** * @author wangchengm * @desc 介绍最基础的rx使用方法，从rx1.0使用过度到rx
RxJS的秘密 Observable 可观察对象
小辣抓
07-26 4745
前言最近因为Angular2了解到了RxJS这个东西，总的来说，RxJS的出现也是为了解决异步回调的，它针对于事件序列。RxJS是一个通过使用可观察序列来构建异步和基于事件的程序的库。它提供了一个核心类型:Observable、卫星类型(大概是这些类型均围绕于Observable，也就是Observable是根基，而这些是辅助类型):Observer、Schedulers、Subjects)和操作符
Rxjs入门2-RxJs诞生、Observable[简介、创建、订阅]、调试工具、Observable[执行、清理]、Observer、Subscription[取消多个订阅]
尊哥的博客
05-18 2975
10、RxJs的诞生 Rx最近在各个领域都非常火. 其实Rx是微软在好多年前针对C#写的一个开源类库， 但好多年都不温不火，一直到Netflix针对Java平台做出了RxJava版本后才在开源社区热度飞速蹿升。当然Rx还在其他语言有所实现，如RxAndroid、RxSwift、RxNet等。 官网给出了以下几种用来解决异步事件管理的基本概念： 是不是很懵懂？没关系，下面咱们具体介绍一下...
RXJava学习（二）：Observable 和observel订阅流程的详细介绍
牛米的博客
02-09 3095
在上篇文章简单的介绍了RXjava的使用与概念，在这篇文章中将会大概的介绍Observable和Observel、Observel的实现类Subscriber，详细地分析subscribe订阅的代码及流程。 Observel和Subscriber   Observel是一个接口，至于为什么是一个接口，自行体会。Observel其中有三个回调的方法：         OnNext():其作用相
RxJava 基本实现
weixin_43800535的博客
01-02 280
RxJava 库的基本使用
WIFI模块转换学习笔记
最新发布
06-12
WIFI模块转换学习笔记 WIFI模块转换是一种将串口信号转换为WIFI信号的技术，可以实现无线通信和远程控制。WIFI模块通常包括芯片和天线两部分，芯片负责信号处理和转换，天线负责信号发射和接收。在学习WIFI模块转换之前，需要了解WIFI技术的基础知识和串口通信的基本原理。 1. WIFI技术的基础知识 WIFI技术是一种无线局域网技术，可以实现电子设备之间的无线通信。WIFI技术使用了IEEE 802.11协议，包括多种不同的标准，如IEEE 802.11a、IEEE 802.11b、IEEE 802.11g、IEEE 802.11n和IEEE 802.11ac等。这些标准都支持不同的频率、速率和传输距离，可以根据具体需求进行选择。 2. 串口通信的基本原理 串口通信是一种通过串行通信协议将数据传输到计算机的方法，其中数据位、停止位和奇偶校验位等参数会影响通信成功率。串口通信通常使用RS-232或RS-485标准通信协议。在Arduino开发板中，可以使用串口库函数来实现串口通信。 3. WIFI模块转换的基本原理 WIFI模块转换是一种将串口信号转换为WIFI信号的技术，可以实现无线通信和远程控制。常见的WIFI模块包括ESP8266和ESP32等。这些WIFI模块可以通过简单的AT指令控制，实现WIFI信号的连接和传输。在Arduino开发板中，可以使用ESP8266库或ESP32库函数来控制WIFI模块。 4. WIFI模块转换的实验 为了学习WIFI模块转换，我们可以进行一个简单的实验。首先，我们需要准备一个WIFI模块，如ESP8266或ESP32。接着，我们需要将WIFI模块连接到Arduino开发板中，可以使用杜邦线将WIFI模块的串口引脚（TX、RX）分别连接到Arduino开发板的数字引脚（D1、D2）上。然后，我们需要编写一个Arduino程序，调用ESP8266库或ESP32库函数，实现WIFI信号的连接和传输。在程序中，我们需要设置WIFI的SSID和密码，以及WIFI模块的AT指令。最后，我们可以使用串口调试助手来监控WIFI信号的传输情况，以确保程序的正确性。 总的来说，学习WIFI模块转换需要了解WIFI技术的基础知识和串口通信的基本原理，以及掌握WIFI模块的使用方法和编程技巧。通过实验的实践，可以更好地理解和应用WIFI模块转换技术，实现无线通信和远程控制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值