RxJava+Retrofit框架Demo

标签: Retrofit
6551人阅读 评论(0) 收藏 举报
分类:

转自:http://www.jianshu.com/p/2b0aeb6b6b61

从年前一两个月开始,就开始慢慢接触RxJava+Retrofit,针对以往开发中遇到的情况,慢慢写了一个框架Demo。文章不在进行入门介绍,需要了解的同学,可以查看笔者总结的文章RxJava、Retrofit

分割Response
一般来说,网络请求结果包括以下信息:

{
  "message": "操作成功",
  "code": "1",
  "object": {}
}

我们可以定义一个对象Response,其中泛型T来表示object,可能是数组,也可能是对象。code为1(或者其他值,和后台商议)表示接口调用成功,如:登录成功,注册成功等;code为其他值,则表示失败,如登录失败等,此时message便返回对应的错误信息,如密码错误等。
如果返回结果为Response,则每次网络请求都要判断接口是否调用成功,比较麻烦,我们希望的是:如果接口调用成功,返回泛型T,即object;如果调用失败,则返回code、message信息。因此,需要对返回结果进行分割处理。
分割操作代码如下:

/**
 * 对网络接口返回的Response进行分割操作
 *
 * @param response
 * @param <T>
 * @return
 */
public <T> Observable<T> flatResponse(final Response<T> response) {
    return Observable.create(new Observable.OnSubscribe<T>() {

        @Override
        public void call(Subscriber<? super T> subscriber) {
            if (response.isSuccess()) {
                if (!subscriber.isUnsubscribed()) {
                    subscriber.onNext(response.object);
                }
            } else {
                if (!subscriber.isUnsubscribed()) {
                    subscriber.onError(new APIException(response.code, response.message));
                }
                return;
            }

            if (!subscriber.isUnsubscribed()) {
                subscriber.onCompleted();
            }

        }
    });
}

其中response.isSuccess()的代码如下:

public boolean isSuccess() {
    return code.equals(Constant.OK);
}

通过以上代码,便可实现分割操作,这样每次返回结果都不用通过code来判断是否成功。

打印请求地址+参数

有些时候,为了方便调试,我们需要将网络请求的地址和参数log出来。由于Retrofit是基于OKHttp的,所以我们需要通过Interceptors来拦截OKHttp来log所需信息。
关于Interceptors,不再多说,直接附上代码。代码来自HttpLoggingInterceptor ,做了简化。

package com.sunflower.rxandroiddemo.utils;


import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;

import okhttp3.Headers;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.Protocol;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.internal.Platform;
import okio.Buffer;

/**
 * Created by Sunflower on 2016/1/12.
 */
public class HttpLoggingInterceptor implements Interceptor {
    private static final Charset UTF8 = Charset.forName("UTF-8");

    public enum Level {
        /**
         * No logs.
         */
        NONE,
        /**
         * Logs request and response lines.
         * <p/>
         * Example:
         * <pre>{@code
         * --> POST /greeting HTTP/1.1 (3-byte body)
         * <p/>
         * <-- HTTP/1.1 200 OK (22ms, 6-byte body)
         * }</pre>
         */
        BASIC,
        /**
         * Logs request and response lines and their respective headers.
         * <p/>
         * Example:
         * <pre>{@code
         * --> POST /greeting HTTP/1.1
         * Host: example.com
         * Content-Type: plain/text
         * Content-Length: 3
         * --> END POST
         * <p/>
         * <-- HTTP/1.1 200 OK (22ms)
         * Content-Type: plain/text
         * Content-Length: 6
         * <-- END HTTP
         * }</pre>
         */
        HEADERS,
        /**
         * Logs request and response lines and their respective headers and bodies (if present).
         * <p/>
         * Example:
         * <pre>{@code
         * --> POST /greeting HTTP/1.1
         * Host: example.com
         * Content-Type: plain/text
         * Content-Length: 3
         * <p/>
         * Hi?
         * --> END GET
         * <p/>
         * <-- HTTP/1.1 200 OK (22ms)
         * Content-Type: plain/text
         * Content-Length: 6
         * <p/>
         * Hello!
         * <-- END HTTP
         * }</pre>
         */
        BODY
    }

    public interface Logger {
        void log(String message);

        /**
         * A {@link Logger} defaults output appropriate for the current platform.
         */
        Logger DEFAULT = new Logger() {
            @Override
            public void log(String message) {
                Platform.get().log(message);
            }
        };
    }

    public HttpLoggingInterceptor() {
        this(Logger.DEFAULT);
    }

    public HttpLoggingInterceptor(Logger logger) {
        this.logger = logger;
    }

    private final Logger logger;

    private volatile Level level = Level.BODY;

    /**
     * Change the level at which this interceptor logs.
     */
    public HttpLoggingInterceptor setLevel(Level level) {
        if (level == null) throw new NullPointerException("level == null. Use Level.NONE instead.");
        this.level = level;
        return this;
    }

    @Override
    public Response intercept(Interceptor.Chain chain) throws IOException {
        Level level = this.level;

        Request request = chain.request();
        if (level == Level.NONE) {
            return chain.proceed(request);
        }

        boolean logBody = level == Level.BODY;
        boolean logHeaders = logBody || level == Level.HEADERS;

        RequestBody requestBody = request.body();
        boolean hasRequestBody = requestBody != null;

        String requestStartMessage = request.method() + ' ' + request.url();
        if (!logHeaders && hasRequestBody) {
            requestStartMessage += " (" + requestBody.contentLength() + "-byte body)";
        }
        logger.log(requestStartMessage);

        if (logHeaders) {

            if (!logBody || !hasRequestBody) {
                logger.log("--> END " + request.method());
            } else if (bodyEncoded(request.headers())) {
                logger.log("--> END " + request.method() + " (encoded body omitted)");
            } else if (request.body() instanceof MultipartBody) {
                //如果是MultipartBody,会log出一大推乱码的东东
            } else {
                Buffer buffer = new Buffer();
                requestBody.writeTo(buffer);

                Charset charset = UTF8;
                MediaType contentType = requestBody.contentType();
                if (contentType != null) {
                    contentType.charset(UTF8);
                }

                logger.log(buffer.readString(charset));

//                logger.log(request.method() + " (" + requestBody.contentLength() + "-byte body)");
            }
        }

        long startNs = System.nanoTime();
        Response response = chain.proceed(request);
        long tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs);
        logger.log(response.code() + ' ' + response.message() + " (" + tookMs + "ms" + ')');

        return response;
    }

    private boolean bodyEncoded(Headers headers) {
        String contentEncoding = headers.get("Content-Encoding");
        return contentEncoding != null && !contentEncoding.equalsIgnoreCase("identity");
    }

    private static String protocol(Protocol protocol) {
        return protocol == Protocol.HTTP_1_0 ? "HTTP/1.0" : "HTTP/1.1";
    }
}

这样在初始化Retrofit时,我们可以通过以下代码来log请求地址+参数

HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
    @Override
    public void log(String message) {
        Log.i("RxJava", message);
    }
});
OkHttpClient client = new OkHttpClient.Builder()
        //log请求参数
        .addInterceptor(interceptor)
        .build();

结果如下:
这里写图片描述

ApiWrapper封装类

对于一个APP来说,我们需要建立一个或者多个接口(我们先分析一个接口的情况,下文用APIService来替代),里面是相应的网络请求,然而不可能每次请求都初始化一个Retrofit对象,进而获得APIService对象,传入对应参数,进行网络请求,处理返回结果。
所以,首先可以新建RetrofitUtil类,用于初始化操作,网络结果分割操作等等;然后新建ApiWrapper封装类(继承自RetrofitUtil)。新建ApiWrapper封装类有什么好处呢?用代码来说明吧!
比说在APIService中有这样一个网络请求方法:

@FormUrlEncoded
@POST("api/common/msg.json")
Observable<Response<String>> getSmsCode(@Field("mobile") String mobile, @Field("appType") String appType);

该方法是用来获取短信验证码的,需要传入两个参数:手机号、app类型(医生端or孕妇端)
由于返回结果为验证码,即object字段为String类型,所以返回结果是Response
通过ApiWrapper封装后,代码如下:

public Observable<String> getSmsCode(String mobile) {
    return getService().getSmsCode(mobile, "GRAVIDA")
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .flatMap(new Func1<Response<String>, Observable<String>>() {
                @Override
                public Observable<String> call(Response<String> stringResponse) {
                    return flatResponse(stringResponse);
                }
            });
}

其中getService()为父类RetrofitUtil中获取APIService对象的方法。
这样的话,在对应Activity中调用起来就很方便了

ApiWrapper wrapper = new ApiWrapper();
wrapper.getSmsCode(mobile)
        .subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(String s) {
                Log.i(TAG, "call " + s);
            }
        });

通过以上代码,我们可以发现封装类有以下好处:

  • 传递某些固定参数,如上述代码中的String appType,或者userId等
  • 对网络请求返回结果进行分割操作
  • 可以进行线程控制

进一步封装

public Observable<String> getSmsCode(String mobile) {
    return getService().getSmsCode(mobile, "GRAVIDA")
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .flatMap(new Func1<Response<String>, Observable<String>>() {
                @Override
                public Observable<String> call(Response<String> stringResponse) {
                    return flatResponse(stringResponse);
                }
            });
}

从这个方法中,我们可以清楚地看到数据是如何在一系列操作符之间进行转换的。但是以后每个网络请求都将进行这样的重复操作。
如何将一组操作符重用于多个数据流中呢?例如,因为希望在工作线程中处理数据,在主线程中处理结果,然后分割网络请求结果。所以我会频繁使用subscribeOn()、observeOn()、flatMap()。如果我能够通过重用的方式,将这种逻辑运用到我所有的数据流中,将是一件多么棒的事。
RxJava提供了一种解决方案:Transformer(有转换器意思),一般情况下可以通过使用操作符Observable.compose()来实现。
Transformer实际上就是一个Func1

/**
 *
 * @param <T>
 * @return
 */
protected <T> Observable.Transformer<Response<T>, T> applySchedulers() {
    return new Observable.Transformer<Response<T>, T>() {
        @Override
        public Observable<T> call(Observable<Response<T>> responseObservable) {
            return responseObservable.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .flatMap(new Func1<Response<T>, Observable<T>>() {
                        @Override
                        public Observable<T> call(Response<T> tResponse) {
                            return flatResponse(tResponse);
                        }
                    })
                    ;
        }
    };
}

恩,没错,这一部分内容参考了注释内的链接,大家可以去看下这篇帖子。
通过上面的方法,我们将Observable

public Observable<String> getSmsCode(String mobile) {
    return getService().getSmsCode(mobile, "GRAVIDA")
            .compose(this.<String>applySchedulers());
}

由于要经常调用applySchedulers()方法,可以考虑创造一个实例化Transformer,节省不必要的实例化对象。代码如下:

final Observable.Transformer transformer = new Observable.Transformer() {
    @Override
    public Object call(Object observable) {
        return ((Observable) observable).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .flatMap(new Func1() {
                    @Override
                    public Object call(Object response) {
                        return flatResponse((Response<Object>)response);
                    }
                })
                ;
    }
};
protected <T> Observable.Transformer<Response<T>, T> applySchedulers() {
    return (Observable.Transformer<Response<T>, T>) transformer;
}

Note

.flatMap(new Func1() {
@Override
public Object call(Object response) {
return flatResponse((Response)response);
}
})

flatResponse()进行类型强转的话,应该没问题吧?笔者暂时不确定,但目前也没发现什么问题。

封装Subscriber
在Activity中我们调用getSmsCode()代码如下:

ApiWrapper wrapper = new ApiWrapper();
showLoadingDialog();
wrapper.getSmsCode(mobile)
        .subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onNext(String s) {
                Log.i(TAG, "call " + s);
            }
        });

其实,对于大部分请求来说,我们只需处理onNext() 方法,默认在onCompleted()方法中hideLoadingDialog();在onError()方法中Toast对应的错误信息。
所以我们可以进一步封装Subscriber,代码如下:

/**
 * 创建观察者
 *
 * @param onNext
 * @param <T>
 * @return
 */
protected <T> Subscriber newSubscriber(final Action1<? super T> onNext) {
    return new Subscriber<T>() {
        @Override
        public void onCompleted() {
            hideLoadingDialog();
        }
        @Override
        public void onError(Throwable e) {
            if (e instanceof RetrofitUtil.APIException) {
                RetrofitUtil.APIException exception = (RetrofitUtil.APIException) e;
                showToast(exception.message);
            } else if (e instanceof SocketTimeoutException) {
                showToast(e.getMessage());
            } else if (e instanceof ConnectException) {
                showToast(e.getMessage());
            }
            Log.e(TAG, String.valueOf(e.getMessage()));
            //e.printStackTrace();
            hideLoadingDialog();
        }
        @Override
        public void onNext(T t) {
            if (!mCompositeSubscription.isUnsubscribed()) {
                onNext.call(t);
            }
        }
    };
}

在onError()方法中,可以根据Throwable e的类型进行对应处理,其中APIException是我们自定义的异常,SocketTimeoutException、ConnectException则是OKHttp返回的异常。
在onCompleted()和onError()中,我们都需要hideLoadingDialog()。

在subscribe()之后, Observable会持有 Subscriber的引用,这个引用如果不能及时被释放,将有内存泄露的风险。所以最好保持一个原则:要在不再使用的时候尽快在合适的地方(例如 onPause()、onStop()等方法中)调用 unsubscribe()来解除引用关系,以避免内存泄露的发生。

我们可以在BaseActivity中声明一个对象

/**
 * 使用CompositeSubscription来持有所有的Subscriptions
 */
protected CompositeSubscription mCompositeSubscription;

在onCreate()方法中初始化:

mCompositeSubscription = new CompositeSubscription();

在onDestroy()中unsubscribe()接触引用关系:

@Override
protected void onDestroy() {
    super.onDestroy();
    //一旦调用了 CompositeSubscription.unsubscribe(),这个CompositeSubscription对象就不可用了,
    // 如果还想使用CompositeSubscription,就必须在创建一个新的对象了。
    mCompositeSubscription.unsubscribe();
}

在Activity中调用网络请求时:

Subscription subscription = wrapper.getSmsCode2("15813351726")
        .subscribe(newSubscriber(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "call " + s);
            }
        }));
mCompositeSubscription.add(subscription);

所以在newSubscriber()中的onNext()方法中,我们需要事先判断mCompositeSubscription是否已经解除了引用。
代码地址在RxAndroidDemo https://github.com/sunflower-zyb/RxAndroidDemo

下面主要说明在日常工作中常用到请求。

上传数组

假设这样一个需求,需要取消收藏多篇文章,以数组的形式传递文章id,代码如下:

@FormUrlEncoded
@POST("api/gravida/article/unfavourite.json")
Observable<Response<Object>> cancelFavorite(@Field("id") String id, @Field("articleId") List<Long> articleId);

这样,只需传递List articleId即可

上传单个文件

一般在更新个人资料时,需要上传头像文件

@Multipart
@POST("api/gravida/personal/update.json")
Observable<Response<PersonalInfo>> updatePersonalInfo(@PartMap Map<String, RequestBody> params);

使用postman查看时,
这里写图片描述

会发现编码方式为multipart/form-data,另外需要注意头像(文件)的参数是:

Content-Disposition: form-data; name="avatar"; filename="Chrysanthemum.jpg"
Content-Type: image/jpeg

封装后的代码是:

/**
 * 上传单个文件
 *
 * @param path 文件路径
 * @return
 */
public Observable<PersonalInfo> updatePersonalInfo(String path) {
    File file = new File(path);
    RequestBody id = RequestBody.create(MediaType.parse("text/plain"), "139");
    //直接传递文件
    //RequestBody avatar = RequestBody.create(MediaType.parse("image/*"), file);
    //传递byte[]
    Bitmap bitmap = ClippingPicture.decodeBitmapSd(path);
    RequestBody avatar = RequestBody.create(MediaType.parse("image/*"), ClippingPicture.bitmapToBytes(bitmap));
    Map<String, RequestBody> params = new HashMap<>();
    params.put("id", id);
    params.put("avatar\"; filename=\"" + file.getName() + "", avatar);
    return getService().updatePersonalInfo(params)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .flatMap(new Func1<Response<PersonalInfo>, Observable<PersonalInfo>>() {
                @Override
                public Observable<PersonalInfo> call(Response<PersonalInfo> personalInfoResponse) {
                    return flatResponse(personalInfoResponse);
                }
            });
}

通过RequestBody.create()创建RequestBody对象。对于文件,可以使用File,亦可以使用byte[]。
请注意Map

上传多个文件

如果需要同时上传多个文件,代码如下:

/**
 * 同时传递多个文件
 *
 * @param orderId   订单id
 * @param productId 产品id
 * @param content   评论内容
 * @param paths     评论的图片路径
 * @return
 */
public Observable<Object> commentProduct(long orderId, long productId, String content, List<String> paths) {
    RequestBody id = RequestBody.create(MediaType.parse("text/plain"), "166");
    RequestBody orderIdBody = RequestBody.create(MediaType.parse("text/plain"), String.valueOf(orderId));
    RequestBody productIdBody = RequestBody.create(MediaType.parse("text/plain"), String.valueOf(productId));
    RequestBody contentBody = RequestBody.create(MediaType.parse("text/plain"), content);
    Map<String, RequestBody> params = new HashMap<>();
    params.put("id", id);
    params.put("orderId", orderIdBody);
    params.put("productId", productIdBody);
    params.put("content", contentBody);
    for (String image : paths) {
        File file = new File(image);
        RequestBody images = RequestBody.create(MediaType.parse("image/*"), file);
        params.put("images\"; filename=\"" + file.getName() + "", images);
    }
    return getService().commentProduct(params)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .flatMap(new Func1<Response<Object>, Observable<?>>() {
                @Override
                public Observable<?> call(Response<Object> objectResponse) {
                    return flatResponse(objectResponse);
                }
            })
            ;
}

postman编码后的参数如下:
这里写图片描述
关键代码是:

for (String image : paths) {
    File file = new File(image);
    RequestBody images = RequestBody.create(MediaType.parse("image/*"), file);
    //key值中为images
    params.put("images\"; filename=\"" + file.getName() + "", images);
}

通过循环来添加文件,其中key值和postman中的参数一致。

同时请求多个接口

在开发过程中,同一个页面的数据是由多个接口共同组成的。所有接口调用完毕后,才可以显示页面数据,结束loading框。
假如我们要在首页同时请求以下三个接口

/**
 * 检查版本
 *
 * @param version
 * @param type
 * @param device
 * @return
 */
@FormUrlEncoded
@POST("api/common/version.json")
Observable<Response<VersionDto>> checkVersion(@Field("version") String version,
                                              @Field("type") String type,
                                              @Field("device") String device);
/**
 * 获取个人信息
 *
 * @param id
 * @return
 */
@FormUrlEncoded
@POST("api/gravida/personal/info.json")
Observable<Response<PersonalInfo>> getPersonalInfo(@Field("id") String id);

/**
 * 获取个人配置信息
 *
 * @param id
 * @return
 */
@FormUrlEncoded
@POST("api/gravida/personal/configs.json")
Observable<Response<PersonalConfigs>> getPersonalConfigs(@Field("id") String id);

那么在首页时,我们可以这么做:

//将多个接口的返回结果结合成一个对象
Observable.zip(wrapper.checkVersion(), wrapper.getPersonalInfo(), wrapper.getPersonalConfigs(),
        new Func3<VersionDto, PersonalInfo, PersonalConfigs, HomeRequest>() {
            @Override
            public HomeRequest call(VersionDto versionDto, PersonalInfo personalInfo, PersonalConfigs personalConfigs) {
                HomeRequest request = new HomeRequest();
                request.setVersionDto(versionDto);
                request.setPersonalInfo(personalInfo);
                request.setPersonalConfigs(personalConfigs);
                return request;
            }
        })
        .subscribe(newSubscriber(new Action1<HomeRequest>() {
            @Override
            public void call(HomeRequest request) {
                Log.i(TAG, "versionDto--" + request.getVersionDto().toString());
                Log.i(TAG, "personalInfo--" + request.getPersonalInfo().toString());
                Log.i(TAG, "PersonalConfigs--" + request.getPersonalConfigs().toString());
            }
        }))
;

通过RxJava的zip()操作符,我们可以将网络请求组合起来,并用Func3(因为是将3个操作组合在一起了)将3个接口的返回结果组合成HomeRequest

/**
 * Represents a function with three arguments.
 */
public interface Func3<T1, T2, T3, R> extends Function {
    R call(T1 t1, T2 t2, T3 t3);
}

连续请求

有时候,我们需要用A接口的请求结果来请求B接口。
如:需要首先获取帖子分类列表,根据帖子分类id,进而获取该分类的帖子列表。
接口如下:

/**
 * 获取帖子分类列表
 *
 * @return
 */
@POST("api/gravida/article/categories.json")
Observable<Response<List<ArticleCategory>>> getArticleCategory();
/**
 * 根据分类获取帖子列表
 *
 * @param id         分类id
 * @param pageNumber
 * @param pageSize
 * @return
 */
@FormUrlEncoded
@POST("api/gravida/article/list.json")
Observable<Response<List<ArticleListDTO>>> getArticleList(@Field("id") long id,
                                                          @Field("pageNumber") int pageNumber,
                                                          @Field("pageSize") int pageSize);

在相应页面,代码如下:

wrapper.getArticleCategory()
        //可以在doOnNext处理数据
        .doOnNext(new Action1<List<ArticleCategory>>() {
            @Override
            public void call(List<ArticleCategory> articleCategories) {
                categoryId = articleCategories.get(0).getId();
            }
        })
        .flatMap(new Func1<List<ArticleCategory>, Observable<List<ArticleListDTO>>>() {
            @Override
            public Observable<List<ArticleListDTO>> call(List<ArticleCategory> articleCategories) {
                return wrapper.getArticleList(categoryId, 1);
            }
        })
        .subscribe(newSubscriber(new Action1<List<ArticleListDTO>>() {
            @Override
            public void call(List<ArticleListDTO> articleList) {
                for (ArticleListDTO article : articleList) {
                    Log.i(TAG, article.getId() + " " + article.getTitle() + " " + article.getIntro());
                }
            }
        }));

我们可以在doOnNext()中对数据进行处理,如保存categoryId帖子id,通过一个flatMap()操作将List转化为Observable

多次请求

有些接口因网络异常或者超时时,需要多次请求。代码如下:

wrapper.getArticleCategory()
        //可以在doOnNext处理数据
        .doOnNext(new Action1<List<ArticleCategory>>() {
            @Override
            public void call(List<ArticleCategory> articleCategories) {
                categoryId = articleCategories.get(0).getId();
            }
        })
         //设置请求次数
        .retry(new Func2<Integer, Throwable, Boolean>() {
            @Override
            public Boolean call(Integer integer, Throwable throwable) {
                Log.e(TAG, "call " + integer);
                if (throwable instanceof SocketTimeoutException && integer < 2)
                    return true;
                else
                    return false;
            }
        })
        .subscribe(newSubscriber(new Action1<List<ArticleCategory>>() {
            @Override
            public void call(List<ArticleCategory> articleCategories) {

            }
        }));

如果是SocketTimeoutException连接超时,或者integer请求次数小于2,则返回true,即需要retry()。

总结

RxJava还有很多操作符,大家可以根据自己的需求来使用。

1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:10361756次
    • 积分:74381
    • 等级:
    • 排名:第24名
    • 原创:505篇
    • 转载:916篇
    • 译文:4篇
    • 评论:2227条
    打赏
    如果您认为本博客不错,读后觉得有收获,不妨打赏赞助我一下,让我有动力继续写出高质量的博客。



    赠人玫瑰,手有余香。分享技术,传递快乐。

    有心课堂,传递的不仅仅是技术!

    QQ交流群:183899857

    有心课堂会员,请加入VIP QQ交流群:213725333

    github
    我的视频
    博客专栏
    最新评论