1、响应式编程基础概念

    public interface Observer {
    void update(String event);
    }
    
    class Subject {
     
    private final List<Observer> observers = new ArrayList<>();
      
    private void notifyObservers(String event) {
        observers.forEach(observer -> observer.update(event));
    }
      
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
      
    public void scanSystemIn() {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String line = scanner.nextLine();
            notifyObservers(line);
        }
    }
    }
    
    public class ObserverDemo {
    public static void main(String[] args) {
        System.out.println("Enter Text : ");
        Subject subject = new Subject();
        
        subject.addObserver(event -> {
            System.out.println("Received response: " + event);
        });
    
        subject.scanSystemIn();
    }
    }

    /** * Publisher is a provider of a potentially unbounded number of sequenced elements, publishing them according to the demand received from its Subscriber.
     * * Publisher can serve multiple Subscriber subscribed dynamically at various points in time.
     * */
    public interface Publisher<T> {
    
    /** * Request Publisher to start streaming data.
     * * This is a "factory method" and can be called multiple times, each time starting a new Subscription.
     * * Each Subscription will work for only a single Subscriber.
     * * A Subscriber should only subscribe once to a single Publisher.
     * * If the Publisher rejects the subscription attempt or otherwise fails it will signal the error via Subscriber#onError.
     * * @param s the Subscriber that will consume signals from this Publisher
     */
    public void subscribe(Subscriber<? super T> s);
    }

    /** * Will receive call to  #onSubscribe(Subscription)} once after passing an instance of Subscriber to Publisher#subscribe(Subscriber)
     * * No further notifications will be received until Subscription#request(long) is called.
     * <p>
     * After signaling demand:
     * *     One or more invocations of #onNext(Object) up to the maximum number defined by Subscription#request(long)
     *     Single invocation of #onError(Throwable) or #onComplete() which signals a terminal state after which no further events will be sent.
     * * Demand can be signaled via Subscription#request(long) whenever the Subscriber instance is capable of handling more.
     * * @param <T> the type of element signaled.
     */
    public interface Subscriber<T> {
    /** * Invoked after calling Publisher#subscribe(Subscriber)
     * * No data will start flowing until Subscription#request(long) is invoked.
     * * It is the responsibility of this Subscriber instance to call Subscription#request(long) whenever more data is wanted.
     * * The Publisher will send notifications only in response to Subscription#request(long).
     * * @param s Subscription that allows requesting data via Subscription#request(long)
     */
    public void onSubscribe(Subscription s);
    
    /** * Data notification sent by the Publisher in response to requests to Subscription#request(long)
     * * @param t the element signaled
     */
    public void onNext(T t);
    
    /** * Failed terminal state.
     * * No further events will be sent even if Subscription#request(long) is invoked again.
     * * @param t the throwable signaled
     */
    public void onError(Throwable t);
    
    /** * Successful terminal state.
     * * No further events will be sent even if Subscription#request(long) is invoked again.
     */
    public void onComplete();
    }

    /** * A Subscription represents a one-to-one lifecycle of a Subscriber subscribing to a Publisher.
     * * It can only be used once by a single Subscriber
     * * It is used to both signal desire for data and cancel demand (and allow resource cleanup).
     * */
    public interface Subscription {
    /** * No events will be sent by a Publisher until demand is signaled via this method.
     * *  It can be called however often and whenever needed—but if the outstanding cumulative demand ever becomes Long.MAX_VALUE or more,
     *  it may be treated by the Publisher as "effectively unbounded".
     * * Whatever has been requested can be sent by the Publisher so only signal demand for what can be safely handled.
     * * A Publisher can send less than is requested if the stream ends but then must emit either Subscriber#onError(Throwable) or Subscriber#onComplete()
     * * @param n the strictly positive number of elements to requests to the upstream Publisher
     */
    public void request(long n);
    
    /** * Request the Publisher to stop sending data and clean up resources.
     * * Data may still be sent to meet previously signalled demand after calling cancel.
     */
    public void cancel();
    }

    /** * A Processor represents a processing stage—which is both a Subscriber
     * and a Publisher and obeys the contracts of both.
     * * @param <T> the type of element signaled to the {@link Subscriber}
     * @param <R> the type of element signaled by the {@link Publisher}
     */
    public interface Processor<T, R> extends Subscriber<T>, Publisher<R> {
    }