├── EasyReactive.iml
├── README.md
├── src
    └── com
    │   └── er
    │       ├── Observer.java
    │       ├── Subject.java
    │       ├── Subscriber.java
    │       ├── Subscrition.java
    │       ├── functions
    │           ├── Action1.java
    │           ├── Function.java
    │           └── Function1.java
    │       └── operators
    │           ├── OperatorFilter.java
    │           └── OperatorMap.java
└── test
    └── com
        └── er
            └── OperatorTest.java


/EasyReactive.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="JAVA_MODULE" version="4">
 3 |   <component name="NewModuleRootManager" inherit-compiler-output="true">
 4 |     <exclude-output />
 5 |     <content url="file://$MODULE_DIR$">
 6 |       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
 7 |       <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
 8 |     </content>
 9 |     <orderEntry type="inheritedJdk" />
10 |     <orderEntry type="sourceFolder" forTests="false" />
11 |     <orderEntry type="module-library" scope="TEST">
12 |       <library name="JUnit4">
13 |         <CLASSES>
14 |           <root url="jar://$APPLICATION_HOME_DIR$/lib/junit-4.12.jar!/" />
15 |           <root url="jar://$APPLICATION_HOME_DIR$/lib/hamcrest-core-1.3.jar!/" />
16 |         </CLASSES>
17 |         <JAVADOC />
18 |         <SOURCES />
19 |       </library>
20 |     </orderEntry>
21 |   </component>
22 | </module>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # EasyReactive
2 | 极简的响应式编程框架，通过该框架你可以快速理解响应式编程的方法，以及如何自行构建响应式框架。
3 | 该框架在observer pattern的基础上实现，通过该框架你可以大体地了解响应式框架的一些设计策略，在此基础上你可以自行扩展练习。
4 | 
5 | 


--------------------------------------------------------------------------------
/src/com/er/Observer.java:
--------------------------------------------------------------------------------
1 | package com.er;
2 | 
3 | public interface Observer<T> {
4 |     public void onNext(T state);
5 | }
6 | 


--------------------------------------------------------------------------------
/src/com/er/Subject.java:
--------------------------------------------------------------------------------
 1 | package com.er;
 2 | 
 3 | 
 4 | import com.er.functions.Action1;
 5 | import com.er.functions.Function1;
 6 | import com.er.operators.OperatorFilter;
 7 | import com.er.operators.OperatorMap;
 8 | 
 9 | /**
10 |  * Created by God on 2016/1/22.
11 |  */
12 | public class Subject<T> {
13 | 
14 |     private OnSubscible<T> onSubscible;
15 | 
16 |     public Subject(OnSubscible<T> f) {
17 |         this.onSubscible = f;
18 |     }
19 | 
20 |     public static <T> Subject<T> create(OnSubscible<T> onSubscible) {
21 |         return new Subject(onSubscible);
22 | 
23 |     }
24 | 
25 |     public void subscribe(Subscriber<T> subscribler) {
26 |         if (subscribler == null) {
27 |             throw new NullPointerException("Observer can not be null");
28 |         } else if (this.onSubscible == null) {
29 |             throw new IllegalArgumentException("onSubscribe function can not be null.");
30 |         } else {
31 |             this.onSubscible.call(subscribler);
32 |         }
33 | 
34 |     }
35 | 
36 | 
37 |     public <R> Subject<R> filter(Function1<? super T, Boolean> function) {
38 | 
39 |         return lift(new OperatorFilter(function));
40 |     }
41 | 
42 | 
43 |     public <R> Subject<R> map(Function1<? super T, ? extends R> function) {
44 |         return lift(new OperatorMap(function));
45 |     }
46 | 
47 |     private <R> Subject<R> lift(Operator<? extends R, ? super T> operator) {
48 |         return new Subject<>(new OnSubscible<R>() {
49 |             @Override
50 |             public void call(Subscriber<? super R> o) {
51 |                 Subscriber<? super T> e = operator.call(o);
52 |                 Subject.this.onSubscible.call(e);//上一个Subject引用的onSubscibe
53 | 
54 |             }
55 |         });
56 |     }
57 | 
58 |     public interface OnSubscible<T> extends Action1<Subscriber<? super T>> {
59 |     }
60 | 
61 |     public interface Operator<R, T> extends Function1<Subscriber<? super R>, Subscriber<? super T>> {
62 |     }
63 | 
64 | }
65 | 


--------------------------------------------------------------------------------
/src/com/er/Subscriber.java:
--------------------------------------------------------------------------------
 1 | package com.er;
 2 | 
 3 | /**
 4 |  * Created by God on 2016/1/26.
 5 |  */
 6 | public abstract class Subscriber<T> implements Observer<T>, Subscrition {
 7 |     private Subscriber<?> subscriber;
 8 | 
 9 |     public Subscriber(Subscriber<?> subscriber) {
10 |         this.subscriber = subscriber;
11 |     }
12 | 
13 |     public Subscriber() {
14 | 
15 |     }
16 | 
17 |     @Override
18 |     public void unSubscribe() {
19 | 
20 |     }
21 | 
22 |     @Override
23 |     public boolean isUnSubscribed() {
24 |         return false;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/com/er/Subscrition.java:
--------------------------------------------------------------------------------
 1 | package com.er;
 2 | 
 3 | /**
 4 |  * Created by God on 2016/1/26.
 5 |  */
 6 | public interface Subscrition {
 7 |     void unSubscribe();
 8 |     boolean isUnSubscribed();
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/com/er/functions/Action1.java:
--------------------------------------------------------------------------------
 1 | package com.er.functions;
 2 | 
 3 | /**
 4 |  * Created by God on 2016/1/26.
 5 |  */
 6 | @FunctionalInterface
 7 | public interface Action1<T> extends Function{
 8 |     void call(T var);
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/com/er/functions/Function.java:
--------------------------------------------------------------------------------
1 | package com.er.functions;
2 | 
3 | /**
4 |  * Created by God on 2016/1/29.
5 |  */
6 | public interface Function {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/com/er/functions/Function1.java:
--------------------------------------------------------------------------------
 1 | package com.er.functions;
 2 | 
 3 | /**
 4 |  * Created by God on 2016/1/26.
 5 |  */
 6 | @FunctionalInterface
 7 | public interface Function1<T,R> extends Function{
 8 |     R call(T var);
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/com/er/operators/OperatorFilter.java:
--------------------------------------------------------------------------------
 1 | package com.er.operators;
 2 | 
 3 | 
 4 | import com.er.Subject;
 5 | import com.er.Subscriber;
 6 | import com.er.functions.Function1;
 7 | 
 8 | /**
 9 |  * Created by God on 2016/1/27.
10 |  */
11 | public class OperatorFilter<T> implements Subject.Operator<T, T> {
12 |     Function1<? super T, Boolean> function;
13 | 
14 |     public OperatorFilter(Function1<? super T, Boolean> function) {
15 |         this.function = function;
16 |     }
17 | 
18 |     public Subscriber<? super T> call(Subscriber<? super T> var) {
19 |         return new Subscriber<T>(var) {
20 |             @Override
21 |             public void onNext(T state) {
22 | 
23 |                 if (OperatorFilter.this.function.call(state).booleanValue()) {
24 |                     var.onNext(state);
25 |                 }
26 |             }
27 |         };
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/com/er/operators/OperatorMap.java:
--------------------------------------------------------------------------------
 1 | package com.er.operators;
 2 | 
 3 | 
 4 | import com.er.Subject;
 5 | import com.er.Subscriber;
 6 | import com.er.functions.Function1;
 7 | 
 8 | /**
 9 |  * Created by God on 2016/1/26.
10 |  * operator
11 |  */
12 | public class OperatorMap<T, R> implements Subject.Operator<R, T> {
13 |     private Function1<? super T, ? extends R> convert;
14 | 
15 |     public OperatorMap(Function1<? super T, ? extends R> convert) {
16 |         this.convert = convert;
17 |     }
18 | 
19 | 
20 |     public Subscriber<? super T> call(Subscriber<? super R> o) {
21 | 
22 |         return new Subscriber<T>(o) {
23 |             @Override
24 |             public void onNext(T state) {
25 | 
26 |                 o.onNext(OperatorMap.this.convert.call(state));
27 | 
28 |             }
29 |         };
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/com/er/OperatorTest.java:
--------------------------------------------------------------------------------
 1 | package com.er;
 2 | 
 3 | 
 4 | import com.er.functions.Function1;
 5 | import org.junit.Test;
 6 | 
 7 | /**
 8 |  * Created by God on 2016/1/22.
 9 |  * operator test
10 |  */
11 | public class OperatorTest {
12 | 
13 | 
14 |     @Test
15 |     public void filterTest() {
16 |         Subject<String> subject = Subject.create(new Subject.OnSubscible<String>() {
17 |             @Override
18 |             public void call(Subscriber<? super String> var) {
19 |                 var.onNext("");
20 |             }
21 |         });
22 | 
23 | 
24 |         Subject<String> newSubject = subject.map(var -> var + "_map");
25 | 
26 |         Subject<String> threeSubject = newSubject.filter((Function1<String, Boolean>) var -> var.length() > 10);
27 | 
28 | 
29 |         threeSubject.subscribe(new Subscriber<String>() {
30 |             @Override
31 |             public void onNext(String state) {
32 |                 System.out.println(state);
33 |             }
34 |         });
35 |     }
36 | 
37 |     //map操作测试
38 |     @Test
39 |     public void mapTest() {
40 |         Subject<String> subject = Subject.create(new Subject.OnSubscible<String>() {
41 |             @Override
42 |             public void call(Subscriber<? super String> var) {
43 |                 var.onNext("ok");
44 |             }
45 |         });
46 | 
47 | 
48 |         Subject<String> newSubject = subject.map(var -> var + "_map");
49 | 
50 |         Subject<String> threeSubject = newSubject.map(var -> var + "|||||||||||");
51 | 
52 | 
53 |         threeSubject.subscribe(new Subscriber<String>() {
54 |             @Override
55 |             public void onNext(String state) {
56 |                 System.out.println(state);
57 |             }
58 |         });
59 |     }
60 | 
61 |     @Test
62 |     public void createTest() {
63 |         Subject.create(new Subject.OnSubscible<String>() {
64 |             @Override
65 |             public void call(Subscriber<? super String> var) {
66 |                 var.onNext("ok");
67 |             }
68 |         }).subscribe(new Subscriber<String>() {
69 |             @Override
70 |             public void onNext(String state) {
71 |                 System.out.println(state + "====");
72 |             }
73 |         });
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------