com.landawn.abacus.eventbus.EventBus Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of abacus-common Show documentation
A general programming library in Java/Android. It's easy to learn and simple to use with concise and powerful APIs.
There is a newer version: 5.2.4
/*
 * Copyright (C) 2016 HaiYang Li
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.landawn.abacus.eventbus;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import com.landawn.abacus.annotation.SuppressFBWarnings;
import com.landawn.abacus.logging.Logger;
import com.landawn.abacus.logging.LoggerFactory;
import com.landawn.abacus.util.AndroidUtil;
import com.landawn.abacus.util.ClassUtil;
import com.landawn.abacus.util.IOUtil;
import com.landawn.abacus.util.MoreExecutors;
import com.landawn.abacus.util.N;
import com.landawn.abacus.util.ThreadMode;

// DO NOT try to move me out of this project. Somebody tried and gave up then. I'm small. I'm stay here.
/**
 *  * 
 * final Object strSubscriber_1 = new Subscriber() {
 *     @Override
 *     public void on(String event) {
 *     System.out.println("Subscriber: strSubscriber_1, event: " + event);
 *     }
 * };
 *
 * final Object anySubscriber_2 = new Object() {
 *     @Subscribe(threadMode = ThreadMode.DEFAULT, interval = 1000)
 *     public void anyMethod(Object event) {
 *     System.out.println("Subscriber: anySubscriber_2, event: " + event);
 *     }
 * };
 *
 * final Object anySubscriber_3 = new Object() {
 *     @Subscribe(threadMode = ThreadMode.DEFAULT, sticky = true)
 *     public void anyMethod(Object event) {
 *     System.out.println("Subscriber: anySubscriber_3, event: " + event);
 *     }
 * };
 *
 * final EventBus eventBus = EventBus.getDefault();
 *
 * eventBus.register(strSubscriber_1);
 * eventBus.register(strSubscriber_1);
 * eventBus.register(anySubscriber_2, "eventId_2");
 *
 * eventBus.post("abc");
 * eventBus.postSticky("sticky");
 * eventBus.post("eventId_2", "abc");
 *
 * eventBus.post(123);
 * eventBus.post("eventId_2", 123);
 *
 * eventBus.register(anySubscriber_3);
 * 
 * 
 *
 * @author haiyang li
 */
public class EventBus {

    private static final Logger logger = LoggerFactory.getLogger(EventBus.class);

    private static final Map, List> classMetaSubMap = new ConcurrentHashMap<>();

    private static final Executor DEFAULT_EXECUTOR;

    static {
        if (IOUtil.IS_PLATFORM_ANDROID) {
            DEFAULT_EXECUTOR = AndroidUtil.getThreadPoolExecutor();
        } else {
            final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(//
                    N.max(8, IOUtil.CPU_CORES), // coreThreadPoolSize
                    N.max(64, IOUtil.CPU_CORES), // maxThreadPoolSize
                    180L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

            DEFAULT_EXECUTOR = threadPoolExecutor;

            MoreExecutors.addDelayedShutdownHook(threadPoolExecutor, 120, TimeUnit.SECONDS);
        }
    }

    private final Map> registeredSubMap = new LinkedHashMap<>();

    private final Map> registeredEventIdSubMap = new HashMap<>();

    private final Map stickyEventMap = new IdentityHashMap<>();

    private final String identifier;

    private final Executor executor;

    private final Map> listOfEventIdSubMap = new ConcurrentHashMap<>();

    private List> listOfSubEventSubs = null;

    private Map mapOfStickyEvent = null;

    private static final EventBus INSTANCE = new EventBus("default");

    /**
     * 
     */
    public EventBus() {
        this(N.guid());
    }

    /**
     * 
     *
     * @param identifier 
     */
    public EventBus(final String identifier) {
        this(identifier, DEFAULT_EXECUTOR);
    }

    /**
     * 
     *
     * @param identifier 
     * @param executor 
     */
    public EventBus(final String identifier, final Executor executor) {
        this.identifier = identifier;
        this.executor = executor == null ? DEFAULT_EXECUTOR : executor;

        if (executor != DEFAULT_EXECUTOR && executor instanceof ExecutorService) {
            Runtime.getRuntime().addShutdownHook(new Thread() {
                @Override
                public void run() {
                    final ExecutorService executorService = (ExecutorService) executor;

                    logger.warn("Starting to shutdown task in EventBus");

                    try {
                        executorService.shutdown();

                        executorService.awaitTermination(60, TimeUnit.SECONDS);
                    } catch (InterruptedException e) {
                        logger.warn("Not all the requests/tasks executed in Eventbus are completed successfully before shutdown.");
                    } finally {
                        logger.warn("Completed to shutdown task in Eventbus");
                    }
                }
            });
        }
    }

    /**
     * Gets the default.
     *
     * @return
     */
    public static EventBus getDefault() {
        return INSTANCE;
    }

    /**
     * 
     *
     * @return 
     */
    public String identifier() {
        return identifier;
    }

    /**
     * Returns the subscriber which is registered with specified eventType(or its sub types) and null event id.
     *
     * @param eventType
     * @return
     */
    public List