devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

RxJava 2.0版本使用精炼详解_io.reactivex.rxjava2:rxjava

作者：AllinToyou | 2024-03-24 07:27:20

赞

踩

io.reactivex.rxjava2:rxjava

一，前期基础知识储备

笔者之前写过两篇关于RxJava1.0的文章

《RxJava理论讲解和简单实现》

《RxJava常见操作符讲解》，感兴趣的读者可以看一看。里面有有关RxJava异步操作库的详细介绍,本文不再赘述。

RxJava1.0版本添加依赖：

  1.     implementation 'io.reactivex:rxandroid:1.2.1'
  2.     implementation 'io.reactivex:rxjava:1.2.1'

RxJava2.0版本添加依赖：

  1.     // RxJava2.0
  2.     implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
  3.     implementation 'io.reactivex.rxjava2:rxjava:2.1.3'

注意二者的依赖环境已经发生改变，所以类和接口所处的包都已经发生改变。

目前RxJava已经更新到2.0版本，2.0版本和1.0版本还是有比较大的区别，这里会在下面的代码中有所体现。

二，上代码，具体实现

1. RxJava2的基础使用

从打印“Hello world”开始，给出从简单到复杂的不同实现方式。

1）简单方式

  1.     private static void helloworldSimple() {
  2.         // 创建消费者，消费者接收一个String类型的事件
  3.         Consumer<String> consumer = new Consumer<String>() {
  4.  
  5.             @Override
  6.             public void accept(String s) throws Exception {
  7.                 Log.d(TAG, "accept: 0," + s);
  8.             }
  9.         };
  10.         Observable.just("Hello WOrld").subscribe(consumer);
  11.     }

打印结果：

accept: 0,Hello WOrld

在简单版本中，我们创建了一个消费者consumer，其实也可以称之为订阅者或者观察者，消费者实现accept()方法，接收一个字符串类型的数据或者事件。

被观察者Observable通过just()方法发出一个“Hello World”的呼唤，然后我们使用subscribe方法指定呼唤的接收者或者消费者，即consumer。那么consumer就能接收到被观察者的呼唤，打印出log。

2）复杂方式

  1.     /**
  2.      * Observer相比Consumer，会对消息的处理更加细化
  3.      */
  4.     private static void helloworldComplex() {
  5.         // 创建一个观察者
  6.         Observer<String> observer = new Observer<String>() {
  7.             // 当Observable 调用subscribe方法时会回调该方法
  8.             // onSubscribe表示已经开始观察被观察者了
  9.             @Override
  10.             public void onSubscribe(Disposable d) {
  11.                 Log.d(TAG, "onSubscribe: 1");
  12.             }
  13.             // 调用onSubscribe方法后
  14.             // 表示收到被观察者的消息
  15.             @Override
  16.             public void onNext(String s) {
  17.                 Log.d(TAG, "onNext: 2，" + s);
  18.             }
  19.             // 出错时调用
  20.             @Override
  21.             public void onError(Throwable e) {
  22.  
  23.             }
  24.             // onNext之后调用
  25.             // 表示接收消息结束
  26.             @Override
  27.             public void onComplete() {
  28.                 Log.d(TAG, "onComplete: 3");
  29.             }
  30.         };
  31.  
  32.         Observable.just("Hello World").subscribe(observer);
  33.     }

打印结果为：

  1. onSubscribe: 1
  2. onNext: 2，Hello World
  3. onComplete: 3

这里我们创建了一个Observer而不是一个Consumer，Observer在接口方法上要多很多，有onSubscribe(), onNext(), onError(), onComplete()。被观察者还是Observable，也发出一声“Hello World”，然后通过subscribe指定观察者observer。

从结果中，可以看到observer中方法的调用顺序，onSubscribe()表示已经开始观察被观察者了，onNext()表示收到被观察者的消息，onComplete()表示接收消息结束。所以Observer相比Consumer会对消息的处理更加细化。

3）受控制的复杂方式

  1.     /**
  2.      * 在onSubscribe方法中会接收到一个Disposable对象，
  3.      * 该对象相当于一个开关，如果开关关闭，则观察者不会接收到任何事件或数据
  4.      */
  5.     private static void helloworldComplexDisposable() {
  6.  
  7.         Observer<String> observer = new Observer<String>() {
  8.             // 声明一个Disposable对象
  9.             Disposable disposable;
  10.             @Override
  11.             public void onSubscribe(Disposable d) {
  12.                 disposable = d; // 保存disposable对象
  13.             }
  14.             @Override
  15.             public void onNext(String s) {
  16.                 Log.d(TAG, "onNext: 2，" + s);
  17.                 if (s.equals("No")) {
  18.                     disposable.dispose();
  19.                 }
  20.             }
  21.             @Override
  22.             public void onError(Throwable e) {
  23.  
  24.             }
  25.             @Override
  26.             public void onComplete() {
  27.                 Log.d(TAG, "onComplete: 3");
  28.             }
  29.         };
  30.  
  31.         Observable.just("Hello World","No","No").subscribe(observer);
  32.     }

打印结果如下：

  1. onNext: 2，Hello World
  2. onNext: 2，No

在onSubscribe()方法中会接收一个Disposable对象，该对象相当于一个开关，如果开关关闭，则观察者不会收到任何事件和数据。

使用一个变量保存Disposable对象，在onNext方法中如果传过来的字符串为“No”,则调用dispose()方法关闭事件的接收。被观察者会发出3个字符串，执行结果可以看到最后一个字符串没有打印，甚至onComplete()方法都不会执行。

4）十分复杂的方式

  1.     /**
  2.      * 使用Create方法创建被观察者，并实现subscribe方法，
  3.      * 接收一个ObservableEmitter对象，即被观察者的发射器，发射器能够发出数据和事件
  4.      * 使用链式调用，让代码看起来更加整洁，
  5.      * 上面发出数据和事件，下面接收数据和事件
  6.      */
  7.     private static void helloworldPlus() {
  8.         Observable.create(new ObservableOnSubscribe<String>() {
  9.  
  10.             @Override
  11.             public void subscribe(ObservableEmitter<String> emitter) throws Exception {
  12.                 Log.d(TAG, "subscribe: send hello world");
  13.                 emitter.onNext("hello world");
  14.                 Log.d(TAG, "subscribe: send No");
  15.                 emitter.onNext("No");
  16.                 Log.d(TAG, "subscribe: send No");
  17.                 emitter.onNext("No");
  18.                 Log.d(TAG, "subscribe: send complete");
  19.                 emitter.onComplete();
  20.             }
  21.         }).subscribe(new Observer<String>() {
  22.             @Override
  23.             public void onSubscribe(Disposable d) {
  24.                 Log.d(TAG, "onSubscribe: ");
  25.             }
  26.  
  27.             @Override
  28.             public void onNext(String s) {
  29.                 Log.d(TAG, "onNext: " + s);
  30.             }
  31.  
  32.             @Override
  33.             public void onError(Throwable e) {
  34.                 Log.d(TAG, "onError: ");
  35.             }
  36.  
  37.             @Override
  38.             public void onComplete() {
  39.                 Log.d(TAG, "onComplete: ");
  40.             }
  41.         });
  42.     }

观察者还是原来的观察者，被观察者则使用create()的方法创建出来，并实现了subscribe()方法，接收一个ObservableEmitter对象，即被观察者的发射器，发射器能够发出数据和事件。

打印结果为：

  1. onSubscribe: 
  2. subscribe: send hello world
  3. onNext: hello world
  4. subscribe: send No
  5. onNext: No
  6. subscribe: send No
  7. onNext: No
  8. subscribe: send complete
  9. onComplete:

从打印结果可知，发射器每发出一个数据或者事件，观察者就会收到。上述代码中使用了链式调用，让代码看起来更加整洁。上面发出数据和事件，下面接收数据和事件。

2.RxJava操作符

RxJava提供了大量的操作符来完成对数据的处理，这些操作符也可以理解为函数。如果把RxJava比作一条数据流水线，那么操作符就是一道工序，数据通过这些工序的加工变换，组装，最后生产出我们需要的数据。

记住：操作符都是对被观察发出数据的操作。

1）过滤操作符filter

2019男篮世界杯，中国最终负于委内瑞拉，其中关键一局中国对战波兰，周琦发球失误，罚球失误，将比赛拖入加时赛，最终输掉比赛，由此由来成语“摇头叹琦”。这里演示过滤“摇头叹琦”。

  1.     /**
  2.      * filter 过滤操作符
  3.      */
  4.     private static void filter() {
  5.         Observable.just("姚明","阿联","摇头叹琦","大侄子")
  6.                 .filter(new Predicate<String>() {
  7.                     @Override
  8.                     public boolean test(String s) throws Exception {
  9.                         Log.d(TAG, "test: " + s);
  10.                         return s.equals("摇头叹琦"); // 只检查出摇头叹琦
  11.                     }
  12.                 })
  13.                 .subscribe(new Consumer<String>() {
  14.                     @Override
  15.                     public void accept(String s) throws Exception {
  16.                         Log.d(TAG, "accept: " + s);
  17.                     }
  18.                 });
  19.     }

打印结果为：

  1. test: 姚明
  2. test: 阿联
  3. test: 摇头叹琦
  4. accept: 摇头叹琦
  5. test: 大侄子

2）map变换操作符

  1.  
  2.     private static void map () {
  3.         Student student = new Student("Jack");
  4.         // map操作符，从student类型转换成Developer
  5.         Observable.just(student).map(new Function<Student, Developer>() {
  6.  
  7.             @Override
  8.             public Developer apply(Student student) throws Exception {
  9.                 Log.d(TAG, "apply: " + student.toString());
  10.                 Developer developer = new Developer();
  11.                 developer.setName(student.getName());
  12.                 developer.setSkill("Android");
  13.                 return developer;
  14.             }
  15.         }).subscribe(new Observer<Developer>() {
  16.             @Override
  17.             public void onSubscribe(Disposable d) {
  18.                 Log.d(TAG, "onSubscribe: ");
  19.             }
  20.  
  21.             @Override
  22.             public void onNext(Developer developer) {
  23.                 Log.d(TAG, "onNext: " + developer);
  24.             }
  25.  
  26.             @Override
  27.             public void onError(Throwable e) {
  28.                 Log.d(TAG, "onError: ");
  29.             }
  30.  
  31.             @Override
  32.             public void onComplete() {
  33.                 Log.d(TAG, "onComplete: ");
  34.             }
  35.         });
  36.     }

map操作符能够完成数据类型的转换。被观察者发送出一个student，而观察者想要接收一个developer(两个都是简单的实体类)，那么在student发送给观察者之前，需要对student进行一些培训，让它转换成一个developer。

打印结果为：

  1. onSubscribe: 
  2. apply: Student{name='Jack'}
  3. onNext: Developer{name='Jack', skill='Android'}
  4. onComplete:

结果：被观察者发送出一个Student，在观察者的onNext()方法中收到了一个Developer。

篇幅有限，文中只介绍了两种操作符的用法，更多内容请参考：

RxJava2-Android-Samples

 

3.异步

作为一个异步操作库，RxJava提供了非常方便的API来完成线程的调度，内置的线程调度器有：

  • Schedule.single()，单线程调度器，线程可复用；
  • Schedule.newThread()，为每个任务创建新的线程；
  • Schedule.io()，处理I/O任务，内部线程池实现，可根据需求增长；
  • Schedule.computation()，处理计算任务，如事件循环和回调任务
  • AndroidSchedulers.mainThread()，Android主线程调度器，属于RxAndroid。

线程调度器实际上指定事件或者数据在什么样的线程中处理。这里主要涉及两个API：subscribeOn()和observeOn()

1）subscribeOn

默认情况下，被观察者和观察者在同一线程中执行。而subscribeOn方法实际上是指定被观察者的代码在那种线程中执行。

需要注意的是，subscribeOn方法调用的位置没有特殊指定，它可以放置在其他操作符的前面，中间或者后面，subscribeOn也可以被多次调用，但以第一次调用为准。

2）observerOn

observeOn指定的是后续的操作符以及观察者的代码在什么样的线程中执行。而且observeOn可以被多次调用，每次都生效。

注意observerOn既可以指定被观察者操作符的线程；又可以指定观察者所在的线程。

______________________________________________________________________________

4. RxJava2.0与Retrofit2.0集成

笔者之前写过三篇Retrofit的文章

《Retrofit基础理论和简单实现》

《Retrofit各种注解的使用》

《RxJava+Retrofit完成网络请求》

感兴趣的读者可以去看一看，里面详细阐述了Retrofit2.0的用法，并且结合RxJava1.0实现了简单的网络请求。

1）添加依赖并开启网络权限

  1.     compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
  2.     compile 'io.reactivex.rxjava2:rxjava:2.1.3'
  3.  
  4.     compile 'com.squareup.retrofit2:retrofit:2.3.0'
  5.     compile 'com.squareup.retrofit2:converter-gson:2.3.0'
  6.     compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'
 <uses-permission android:name="android.permission.INTERNET"/>

2）定义网络接口

通过豆瓣API去请求豆瓣电影Top250的网址：

http://douban.uieee.com/v2/movie/top250?start=0&count=10

 

所以定义的接口如下：

  1. public interface Api {
  2.     @GET("top250")
  3.     Observable<MovieBean> listTop250(@Query("start") int start,
  4.                      @Query("count") int count);
  5. }

注意：豆瓣API接口网址可能会有变化，以豆瓣API的官方文档为准。

参数start表示查询数据的起始位置，count表示查询数据的个数。返回Observeable类型而不是Call类型。MovieBean为网络结果解析成的JavaBean。

3) 使用单例模式获取Retrofit实例

  1. public class MovieRetrofit {
  2.  
  3.     private static MovieRetrofit sMovieRetrofit;
  4.     private final Api mApi;
  5.     // 使用单例模式
  6.     public static MovieRetrofit getInstance() {
  7.         if (sMovieRetrofit == null) {
  8.             synchronized (MovieRetrofit.class) {
  9.                 if (sMovieRetrofit == null) {
  10.                     sMovieRetrofit = new MovieRetrofit();
  11.                 }
  12.             }
  13.         }
  14.         return sMovieRetrofit;
  15.     }
  16.  
  17.     private MovieRetrofit() {
  18.         Retrofit retrofit = new Retrofit.Builder().baseUrl("http://douban.uieee.com/v2/movie/")
  19.                 .addConverterFactory(GsonConverterFactory.create())
  20.                 .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
  21.                 .build();
  22.         // 创建网络接口代理
  23.         mApi = retrofit.create(Api.class);
  24.     }
  25.     // 返回API接口对象的实现
  26.     public Api getApi() {
  27.         return mApi;
  28.     }
  29. }

使用单例模式获取Retrofit实例对象, 实现Api的接口,获取接口实例对象.

4)发送网络请求刷新列表

接下来就可以使用接口获取一个Observable对象,通过subscribeOn指定网络请求以及网络响应解析的线程,通过ObserverOn指定刷新UI的线程,实现如下:

  1. /**
  2.  * 简化代码，Activity继承自ListActivity
  3.  */
  4. public class MovieListActivity extends ListActivity {
  5.     private static final String TAG = "MovieListActivity";
  6.  
  7.     @Override
  8.     protected void onCreate(Bundle savedInstanceState) {
  9.         super.onCreate(savedInstanceState);
  10.         // 获取Observable对象，查询排名前25的电影
  11.         Observable<MovieBean> movieBeanObservable = MovieRetrofit.getInstance().getApi().listTop250(0, 25);
  12.         movieBeanObservable.subscribeOn(Schedulers.io())
  13.                 // 将网络结果转为电影名的集合
  14.                 .map(new Function<MovieBean, List<String>>() {
  15.                     @Override
  16.                     public List<String> apply(MovieBean movieBean) throws Exception {
  17.                         List<String> array = new ArrayList<String>();
  18.                         for (int i = 0; i < movieBean.getSubjects().size(); i++) {
  19.                             String title = movieBean.getSubjects().get(i).getTitle();
  20.                             Log.d(TAG, "apply: " + title);
  21.                             array.add(title);
  22.                         }
  23.                         return array;
  24.                     }
  25.                 })
  26.                 .observeOn(AndroidSchedulers.mainThread())
  27.                 .subscribe(new Observer<List<String>>() {
  28.                     @Override
  29.                     public void onSubscribe(Disposable d) {
  30.  
  31.                     }
  32.  
  33.                     @Override
  34.                     public void onNext(List<String> value) {
  35.                         ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>(MovieListActivity.this, 
  36.                                 android.R.layout.simple_list_item_1, value);
  37.                         setListAdapter(arrayAdapter); // 设置Adapter刷新列表
  38.                     }
  39.  
  40.                     @Override
  41.                    public void onError(Throwable e) {
  42.                         Toast.makeText(MovieListActivity.this, "onError", 
  43.                                 Toast.LENGTH_SHORT).show();
  44.                         Log.d(TAG, "onError: " + e.getLocalizedMessage());
  45.                     }
  46.  
  47.                     @Override
  48.                     public void onComplete() {
  49.                         Toast.makeText(MovieListActivity.this, "onComplete", 
  50.                                 Toast.LENGTH_SHORT).show();
  51.                     }
  52.                 });
  53.     }
  54. }

Retrofit和RxJava结合后,就可以使用RxJava对结果进行一系列的操作,当需要对网络结果做一些复杂的处理时,RxJava的优势非常大.

更多RxJava在Android平台的使用,可以参考开源项目:

RxJava-Android-Samples

最后给出用到的实体类MovieBean(实体类比较复杂,建议使用Json网站去自动根据Json数据生成Java Bean.)

 

  1. public class MovieBean {
  2.  
  3. 	private int count;
  4. 	private int start;
  5. 	private int total;
  6. 	private String title;
  7.  
  8. 	private List<SubjectsBean> subjects;
  9.  
  10. 	public int getCount() {
  11. 		return count;
  12. 	}
  13.  
  14. 	public void setCount(int count) {
  15. 		this.count = count;
  16. 	}
  17.  
  18. 	public int getStart() {
  19. 		return start;
  20. 	}
  21.  
  22. 	public void setStart(int start) {
  23. 		this.start = start;
  24. 	}
  25.  
  26. 	public int getTotal() {
  27. 		return total;
  28. 	}
  29.  
  30. 	public void setTotal(int total) {
  31. 		this.total = total;
  32. 	}
  33.  
  34. 	public String getTitle() {
  35. 		return title;
  36. 	}
  37.  
  38. 	public void setTitle(String title) {
  39. 		this.title = title;
  40. 	}
  41.  
  42. 	public List<SubjectsBean> getSubjects() {
  43. 		return subjects;
  44. 	}
  45.  
  46. 	public void setSubjects(List<SubjectsBean> subjects) {
  47. 		this.subjects = subjects;
  48. 	}
  49.  
  50. 	public static class SubjectsBean {
  51.  
  52. 		private RatingBean rating;
  53. 		private String title;
  54. 		private int collect_count;
  55. 		private String original_title;
  56. 		private String subtype;
  57. 		private String year;
  58.  
  59. 		private ImagesBean images;
  60. 		private String alt;
  61. 		private String id;
  62. 		private List<String> genres;
  63.  
  64. 		private List<CastsBean> casts;
  65.  
  66. 		private List<DirectorsBean> directors;
  67.  
  68. 		public RatingBean getRating() {
  69. 			return rating;
  70. 		}
  71.  
  72. 		public void setRating(RatingBean rating) {
  73. 			this.rating = rating;
  74. 		}
  75.  
  76. 		public String getTitle() {
  77. 			return title;
  78. 		}
  79.  
  80. 		public void setTitle(String title) {
  81. 			this.title = title;
  82. 		}
  83.  
  84. 		public int getCollect_count() {
  85. 			return collect_count;
  86. 		}
  87.  
  88. 		public void setCollect_count(int collect_count) {
  89. 			this.collect_count = collect_count;
  90. 		}
  91.  
  92. 		public String getOriginal_title() {
  93. 			return original_title;
  94. 		}
  95.  
  96. 		public void setOriginal_title(String original_title) {
  97. 			this.original_title = original_title;
  98. 		}
  99.  
  100. 		public String getSubtype() {
  101. 			return subtype;
  102. 		}
  103.  
  104. 		public void setSubtype(String subtype) {
  105. 			this.subtype = subtype;
  106. 		}
  107.  
  108. 		public String getYear() {
  109. 			return year;
  110. 		}
  111.  
  112. 		public void setYear(String year) {
  113. 			this.year = year;
  114. 		}
  115.  
  116. 		public ImagesBean getImages() {
  117. 			return images;
  118. 		}
  119.  
  120. 		public void setImages(ImagesBean images) {
  121. 			this.images = images;
  122. 		}
  123.  
  124. 		public String getAlt() {
  125. 			return alt;
  126. 		}
  127.  
  128. 		public void setAlt(String alt) {
  129. 			this.alt = alt;
  130. 		}
  131.  
  132. 		public String getId() {
  133. 			return id;
  134. 		}
  135.  
  136. 		public void setId(String id) {
  137. 			this.id = id;
  138. 		}
  139.  
  140. 		public List<String> getGenres() {
  141. 			return genres;
  142. 		}
  143.  
  144. 		public void setGenres(List<String> genres) {
  145. 			this.genres = genres;
  146. 		}
  147.  
  148. 		public List<CastsBean> getCasts() {
  149. 			return casts;
  150. 		}
  151.  
  152. 		public void setCasts(List<CastsBean> casts) {
  153. 			this.casts = casts;
  154. 		}
  155.  
  156. 		public List<DirectorsBean> getDirectors() {
  157. 			return directors;
  158. 		}
  159.  
  160. 		public void setDirectors(List<DirectorsBean> directors) {
  161. 			this.directors = directors;
  162. 		}
  163.  
  164. 		public static class RatingBean {
  165. 			private int max;
  166. 			private double average;
  167. 			private String stars;
  168. 			private int min;
  169.  
  170. 			public int getMax() {
  171. 				return max;
  172. 			}
  173.  
  174. 			public void setMax(int max) {
  175. 				this.max = max;
  176. 			}
  177.  
  178. 			public double getAverage() {
  179. 				return average;
  180. 			}
  181.  
  182. 			public void setAverage(double average) {
  183. 				this.average = average;
  184. 			}
  185.  
  186. 			public String getStars() {
  187. 				return stars;
  188. 			}
  189.  
  190. 			public void setStars(String stars) {
  191. 				this.stars = stars;
  192. 			}
  193.  
  194. 			public int getMin() {
  195. 				return min;
  196. 			}
  197.  
  198. 			public void setMin(int min) {
  199. 				this.min = min;
  200. 			}
  201. 		}
  202.  
  203. 		public static class ImagesBean {
  204. 			private String small;
  205. 			private String large;
  206. 			private String medium;
  207.  
  208. 			public String getSmall() {
  209. 				return small;
  210. 			}
  211.  
  212. 			public void setSmall(String small) {
  213. 				this.small = small;
  214. 			}
  215.  
  216. 			public String getLarge() {
  217. 				return large;
  218. 			}
  219.  
  220. 			public void setLarge(String large) {
  221. 				this.large = large;
  222. 			}
  223.  
  224. 			public String getMedium() {
  225. 				return medium;
  226. 			}
  227.  
  228. 			public void setMedium(String medium) {
  229. 				this.medium = medium;
  230. 			}
  231. 		}
  232.  
  233. 		public static class CastsBean {
  234. 			private String alt;
  235.  
  236. 			private AvatarsBean avatars;
  237. 			private String name;
  238. 			private String id;
  239.  
  240. 			public String getAlt() {
  241. 				return alt;
  242. 			}
  243.  
  244. 			public void setAlt(String alt) {
  245. 				this.alt = alt;
  246. 			}
  247.  
  248. 			public AvatarsBean getAvatars() {
  249. 				return avatars;
  250. 			}
  251.  
  252. 			public void setAvatars(AvatarsBean avatars) {
  253. 				this.avatars = avatars;
  254. 			}
  255.  
  256. 			public String getName() {
  257. 				return name;
  258. 			}
  259.  
  260. 			public void setName(String name) {
  261. 				this.name = name;
  262. 			}
  263.  
  264. 			public String getId() {
  265. 				return id;
  266. 			}
  267.  
  268. 			public void setId(String id) {
  269. 				this.id = id;
  270. 			}
  271.  
  272. 			public static class AvatarsBean {
  273. 				private String small;
  274. 				private String large;
  275. 				private String medium;
  276.  
  277. 				public String getSmall() {
  278. 					return small;
  279. 				}
  280.  
  281. 				public void setSmall(String small) {
  282. 					this.small = small;
  283. 				}
  284.  
  285. 				public String getLarge() {
  286. 					return large;
  287. 				}
  288.  
  289. 				public void setLarge(String large) {
  290. 					this.large = large;
  291. 				}
  292.  
  293. 				public String getMedium() {
  294. 					return medium;
  295. 				}
  296.  
  297. 				public void setMedium(String medium) {
  298. 					this.medium = medium;
  299. 				}
  300. 			}
  301. 		}
  302.  
  303. 		public static class DirectorsBean {
  304. 			private String alt;
  305.  
  306. 			private AvatarsBean avatars;
  307. 			private String name;
  308. 			private String id;
  309.  
  310. 			public String getAlt() {
  311. 				return alt;
  312. 			}
  313.  
  314. 			public void setAlt(String alt) {
  315. 				this.alt = alt;
  316. 			}
  317.  
  318. 			public AvatarsBean getAvatars() {
  319. 				return avatars;
  320. 			}
  321.  
  322. 			public void setAvatars(AvatarsBean avatars) {
  323. 				this.avatars = avatars;
  324. 			}
  325.  
  326. 			public String getName() {
  327. 				return name;
  328. 			}
  329.  
  330. 			public void setName(String name) {
  331. 				this.name = name;
  332. 			}
  333.  
  334. 			public String getId() {
  335. 				return id;
  336. 			}
  337.  
  338. 			public void setId(String id) {
  339. 				this.id = id;
  340. 			}
  341.  
  342. 			public static class AvatarsBean {
  343. 				private String small;
  344. 				private String large;
  345. 				private String medium;
  346.  
  347. 				public String getSmall() {
  348. 					return small;
  349. 				}
  350.  
  351. 				public void setSmall(String small) {
  352. 					this.small = small;
  353. 				}
  354.  
  355. 				public String getLarge() {
  356. 					return large;
  357. 				}
  358.  
  359. 				public void setLarge(String large) {
  360. 					this.large = large;
  361. 				}
  362.  
  363. 				public String getMedium() {
  364. 					return medium;
  365. 				}
  366.  
  367. 				public void setMedium(String medium) {
  368. 					this.medium = medium;
  369. 				}
  370. 			}
  371. 		}
  372. 	}
  373. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/300732
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号